From 4d432ebbd1222f58376157850d879382827f2ceb Mon Sep 17 00:00:00 2001 From: beau-lunarg Date: Sun, 27 Oct 2024 15:20:50 -0400 Subject: [PATCH] Format --- test/test_apps/common/test_app_base.cpp | 1869 ++++-- test/test_apps/common/test_app_base.h | 497 +- test/test_apps/common/test_app_dispatch.h | 6797 ++++++++++++++------- test/test_apps/multisample-depth/app.cpp | 35 +- test/test_apps/triangle/app.cpp | 17 +- 5 files changed, 6201 insertions(+), 3014 deletions(-) diff --git a/test/test_apps/common/test_app_base.cpp b/test/test_apps/common/test_app_base.cpp index e45ae4740..6bb8f2e87 100644 --- a/test/test_apps/common/test_app_base.cpp +++ b/test/test_apps/common/test_app_base.cpp @@ -46,55 +46,77 @@ GFXRECON_BEGIN_NAMESPACE(test) GFXRECON_BEGIN_NAMESPACE(detail) -GenericFeaturesPNextNode::GenericFeaturesPNextNode() { memset(fields, UINT8_MAX, sizeof(VkBool32) * field_capacity); } +GenericFeaturesPNextNode::GenericFeaturesPNextNode() +{ + memset(fields, UINT8_MAX, sizeof(VkBool32) * field_capacity); +} -bool GenericFeaturesPNextNode::match(GenericFeaturesPNextNode const& requested, GenericFeaturesPNextNode const& supported) noexcept { +bool GenericFeaturesPNextNode::match(GenericFeaturesPNextNode const& requested, + GenericFeaturesPNextNode const& supported) noexcept +{ assert(requested.sType == supported.sType && "Non-matching sTypes in features nodes!"); - for (uint32_t i = 0; i < field_capacity; i++) { - if (requested.fields[i] && !supported.fields[i]) return false; + for (uint32_t i = 0; i < field_capacity; i++) + { + if (requested.fields[i] && !supported.fields[i]) + return false; } return true; } -void GenericFeaturesPNextNode::combine(GenericFeaturesPNextNode const& right) noexcept { +void GenericFeaturesPNextNode::combine(GenericFeaturesPNextNode const& right) noexcept +{ assert(sType == right.sType && "Non-matching sTypes in features nodes!"); - for (uint32_t i = 0; i < GenericFeaturesPNextNode::field_capacity; i++) { + for (uint32_t i = 0; i < GenericFeaturesPNextNode::field_capacity; i++) + { fields[i] = fields[i] || right.fields[i]; } } -bool GenericFeatureChain::match_all(GenericFeatureChain const& extension_requested) const noexcept { +bool GenericFeatureChain::match_all(GenericFeatureChain const& extension_requested) const noexcept +{ // Should only be false if extension_supported was unable to be filled out, due to the // physical device not supporting vkGetPhysicalDeviceFeatures2 in any capacity. - if (extension_requested.nodes.size() != nodes.size()) { + if (extension_requested.nodes.size() != nodes.size()) + { return false; } - for (size_t i = 0; i < nodes.size() && i < nodes.size(); ++i) { - if (!GenericFeaturesPNextNode::match(extension_requested.nodes[i], nodes[i])) return false; + for (size_t i = 0; i < nodes.size() && i < nodes.size(); ++i) + { + if (!GenericFeaturesPNextNode::match(extension_requested.nodes[i], nodes[i])) + return false; } return true; } -bool GenericFeatureChain::find_and_match(GenericFeatureChain const& extensions_requested) const noexcept { - for (const auto& requested_extension_node : extensions_requested.nodes) { +bool GenericFeatureChain::find_and_match(GenericFeatureChain const& extensions_requested) const noexcept +{ + for (const auto& requested_extension_node : extensions_requested.nodes) + { bool found = false; - for (const auto& supported_node : nodes) { - if (supported_node.sType == requested_extension_node.sType) { + for (const auto& supported_node : nodes) + { + if (supported_node.sType == requested_extension_node.sType) + { found = true; - if (!GenericFeaturesPNextNode::match(requested_extension_node, supported_node)) return false; + if (!GenericFeaturesPNextNode::match(requested_extension_node, supported_node)) + return false; break; } } - if (!found) return false; + if (!found) + return false; } return true; } -void GenericFeatureChain::chain_up(VkPhysicalDeviceFeatures2& feats2) noexcept { +void GenericFeatureChain::chain_up(VkPhysicalDeviceFeatures2& feats2) noexcept +{ detail::GenericFeaturesPNextNode* prev = nullptr; - for (auto& extension : nodes) { - if (prev != nullptr) { + for (auto& extension : nodes) + { + if (prev != nullptr) + { prev->pNext = &extension; } prev = &extension; @@ -103,23 +125,28 @@ void GenericFeatureChain::chain_up(VkPhysicalDeviceFeatures2& feats2) noexcept { feats2.pNext = !nodes.empty() ? &nodes.at(0) : nullptr; } -void GenericFeatureChain::combine(GenericFeatureChain const& right) noexcept { - for (const auto& right_node : right.nodes) { +void GenericFeatureChain::combine(GenericFeatureChain const& right) noexcept +{ + for (const auto& right_node : right.nodes) + { bool already_contained = false; - for (auto& left_node : nodes) { - if (left_node.sType == right_node.sType) { + for (auto& left_node : nodes) + { + if (left_node.sType == right_node.sType) + { left_node.combine(right_node); already_contained = true; } } - if (!already_contained) { + if (!already_contained) + { nodes.push_back(right_node); } } } - -class VulkanFunctions { +class VulkanFunctions +{ private: std::mutex init_mutex; @@ -129,36 +156,45 @@ class VulkanFunctions { HMODULE library = nullptr; #endif - bool load_vulkan_library() { + bool load_vulkan_library() + { // Can immediately return if it has already been loaded - if (library) { + if (library) + { return true; } #if defined(__linux__) library = dlopen("libvulkan.so.1", RTLD_NOW | RTLD_LOCAL); - if (!library) library = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL); + if (!library) + library = dlopen("libvulkan.so", RTLD_NOW | RTLD_LOCAL); #elif defined(__APPLE__) library = dlopen("libvulkan.dylib", RTLD_NOW | RTLD_LOCAL); - if (!library) library = dlopen("libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL); - if (!library) library = dlopen("libMoltenVK.dylib", RTLD_NOW | RTLD_LOCAL); + if (!library) + library = dlopen("libvulkan.1.dylib", RTLD_NOW | RTLD_LOCAL); + if (!library) + library = dlopen("libMoltenVK.dylib", RTLD_NOW | RTLD_LOCAL); #elif defined(_WIN32) library = LoadLibrary(TEXT("vulkan-1.dll")); #else assert(false && "Unsupported platform"); #endif - if (!library) return false; + if (!library) + return false; load_func(ptr_vkGetInstanceProcAddr, "vkGetInstanceProcAddr"); return ptr_vkGetInstanceProcAddr != nullptr; } - template void load_func(T& func_dest, const char* func_name) { + template + void load_func(T& func_dest, const char* func_name) + { #if defined(__linux__) || defined(__APPLE__) func_dest = reinterpret_cast(dlsym(library, func_name)); #elif defined(_WIN32) func_dest = reinterpret_cast(GetProcAddress(library, func_name)); #endif } - void close() { + void close() + { #if defined(__linux__) || defined(__APPLE__) dlclose(library); #elif defined(_WIN32) @@ -168,13 +204,18 @@ class VulkanFunctions { } public: - bool init_vulkan_funcs(PFN_vkGetInstanceProcAddr fp_vkGetInstanceProcAddr = nullptr) { + bool init_vulkan_funcs(PFN_vkGetInstanceProcAddr fp_vkGetInstanceProcAddr = nullptr) + { std::lock_guard lg(init_mutex); - if (fp_vkGetInstanceProcAddr != nullptr) { + if (fp_vkGetInstanceProcAddr != nullptr) + { ptr_vkGetInstanceProcAddr = fp_vkGetInstanceProcAddr; - } else { + } + else + { bool ret = load_vulkan_library(); - if (!ret) return false; + if (!ret) + return false; } fp_vkEnumerateInstanceExtensionProperties = reinterpret_cast( @@ -189,44 +230,49 @@ class VulkanFunctions { } public: - template void get_inst_proc_addr(T& out_ptr, const char* func_name) { + template + void get_inst_proc_addr(T& out_ptr, const char* func_name) + { out_ptr = reinterpret_cast(ptr_vkGetInstanceProcAddr(instance, func_name)); } - template void get_device_proc_addr(VkDevice device, T& out_ptr, const char* func_name) { + template + void get_device_proc_addr(VkDevice device, T& out_ptr, const char* func_name) + { out_ptr = reinterpret_cast(fp_vkGetDeviceProcAddr(device, func_name)); } PFN_vkGetInstanceProcAddr ptr_vkGetInstanceProcAddr = nullptr; - VkInstance instance = nullptr; + VkInstance instance = nullptr; PFN_vkEnumerateInstanceExtensionProperties fp_vkEnumerateInstanceExtensionProperties = nullptr; - PFN_vkEnumerateInstanceLayerProperties fp_vkEnumerateInstanceLayerProperties = nullptr; - PFN_vkEnumerateInstanceVersion fp_vkEnumerateInstanceVersion = nullptr; - PFN_vkCreateInstance fp_vkCreateInstance = nullptr; - - PFN_vkDestroyInstance fp_vkDestroyInstance = nullptr; - PFN_vkCreateDebugUtilsMessengerEXT fp_vkCreateDebugUtilsMessengerEXT = nullptr; - PFN_vkDestroyDebugUtilsMessengerEXT fp_vkDestroyDebugUtilsMessengerEXT = nullptr; - PFN_vkEnumeratePhysicalDevices fp_vkEnumeratePhysicalDevices = nullptr; - PFN_vkGetPhysicalDeviceFeatures fp_vkGetPhysicalDeviceFeatures = nullptr; - PFN_vkGetPhysicalDeviceFeatures2 fp_vkGetPhysicalDeviceFeatures2 = nullptr; - PFN_vkGetPhysicalDeviceFeatures2KHR fp_vkGetPhysicalDeviceFeatures2KHR = nullptr; - PFN_vkGetPhysicalDeviceProperties fp_vkGetPhysicalDeviceProperties = nullptr; + PFN_vkEnumerateInstanceLayerProperties fp_vkEnumerateInstanceLayerProperties = nullptr; + PFN_vkEnumerateInstanceVersion fp_vkEnumerateInstanceVersion = nullptr; + PFN_vkCreateInstance fp_vkCreateInstance = nullptr; + + PFN_vkDestroyInstance fp_vkDestroyInstance = nullptr; + PFN_vkCreateDebugUtilsMessengerEXT fp_vkCreateDebugUtilsMessengerEXT = nullptr; + PFN_vkDestroyDebugUtilsMessengerEXT fp_vkDestroyDebugUtilsMessengerEXT = nullptr; + PFN_vkEnumeratePhysicalDevices fp_vkEnumeratePhysicalDevices = nullptr; + PFN_vkGetPhysicalDeviceFeatures fp_vkGetPhysicalDeviceFeatures = nullptr; + PFN_vkGetPhysicalDeviceFeatures2 fp_vkGetPhysicalDeviceFeatures2 = nullptr; + PFN_vkGetPhysicalDeviceFeatures2KHR fp_vkGetPhysicalDeviceFeatures2KHR = nullptr; + PFN_vkGetPhysicalDeviceProperties fp_vkGetPhysicalDeviceProperties = nullptr; PFN_vkGetPhysicalDeviceQueueFamilyProperties fp_vkGetPhysicalDeviceQueueFamilyProperties = nullptr; - PFN_vkGetPhysicalDeviceMemoryProperties fp_vkGetPhysicalDeviceMemoryProperties = nullptr; - PFN_vkEnumerateDeviceExtensionProperties fp_vkEnumerateDeviceExtensionProperties = nullptr; + PFN_vkGetPhysicalDeviceMemoryProperties fp_vkGetPhysicalDeviceMemoryProperties = nullptr; + PFN_vkEnumerateDeviceExtensionProperties fp_vkEnumerateDeviceExtensionProperties = nullptr; - PFN_vkCreateDevice fp_vkCreateDevice = nullptr; + PFN_vkCreateDevice fp_vkCreateDevice = nullptr; PFN_vkGetDeviceProcAddr fp_vkGetDeviceProcAddr = nullptr; - PFN_vkDestroySurfaceKHR fp_vkDestroySurfaceKHR = nullptr; - PFN_vkGetPhysicalDeviceSurfaceSupportKHR fp_vkGetPhysicalDeviceSurfaceSupportKHR = nullptr; - PFN_vkGetPhysicalDeviceSurfaceFormatsKHR fp_vkGetPhysicalDeviceSurfaceFormatsKHR = nullptr; + PFN_vkDestroySurfaceKHR fp_vkDestroySurfaceKHR = nullptr; + PFN_vkGetPhysicalDeviceSurfaceSupportKHR fp_vkGetPhysicalDeviceSurfaceSupportKHR = nullptr; + PFN_vkGetPhysicalDeviceSurfaceFormatsKHR fp_vkGetPhysicalDeviceSurfaceFormatsKHR = nullptr; PFN_vkGetPhysicalDeviceSurfacePresentModesKHR fp_vkGetPhysicalDeviceSurfacePresentModesKHR = nullptr; PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR fp_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = nullptr; - void init_instance_funcs(VkInstance inst) { + void init_instance_funcs(VkInstance inst) + { instance = inst; get_inst_proc_addr(fp_vkDestroyInstance, "vkDestroyInstance"); get_inst_proc_addr(fp_vkCreateDebugUtilsMessengerEXT, "vkCreateDebugUtilsMessengerEXT"); @@ -252,18 +298,23 @@ class VulkanFunctions { } }; -static VulkanFunctions& vulkan_functions() { +static VulkanFunctions& vulkan_functions() +{ static VulkanFunctions v; return v; } // Helper for robustly executing the two-call pattern -template auto get_vector(std::vector& out, F&& f, Ts&&... ts) -> VkResult { +template +auto get_vector(std::vector& out, F&& f, Ts&&... ts) -> VkResult +{ uint32_t count = 0; VkResult err; - do { + do + { err = f(ts..., &count, nullptr); - if (err != VK_SUCCESS) { + if (err != VK_SUCCESS) + { return err; }; out.resize(count); @@ -273,8 +324,10 @@ template auto get_vector(std::vector return err; } -template auto get_vector_noerror(F&& f, Ts&&... ts) -> std::vector { - uint32_t count = 0; +template +auto get_vector_noerror(F&& f, Ts&&... ts) -> std::vector +{ + uint32_t count = 0; std::vector results; f(ts..., &count, nullptr); results.resize(count); @@ -285,8 +338,10 @@ template auto get_vector_noerror(F&& f, GFXRECON_END_NAMESPACE(detail) -const char* to_string_message_severity(VkDebugUtilsMessageSeverityFlagBitsEXT s) { - switch (s) { +const char* to_string_message_severity(VkDebugUtilsMessageSeverityFlagBitsEXT s) +{ + switch (s) + { case VK_DEBUG_UTILS_MESSAGE_SEVERITY_VERBOSE_BIT_EXT: return "VERBOSE"; case VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT: @@ -299,95 +354,131 @@ const char* to_string_message_severity(VkDebugUtilsMessageSeverityFlagBitsEXT s) return "UNKNOWN"; } } -const char* to_string_message_type(VkDebugUtilsMessageTypeFlagsEXT s) { - if (s == 7) return "General | Validation | Performance"; - if (s == 6) return "Validation | Performance"; - if (s == 5) return "General | Performance"; - if (s == 4 /*VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT*/) return "Performance"; - if (s == 3) return "General | Validation"; - if (s == 2 /*VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT*/) return "Validation"; - if (s == 1 /*VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT*/) return "General"; +const char* to_string_message_type(VkDebugUtilsMessageTypeFlagsEXT s) +{ + if (s == 7) + return "General | Validation | Performance"; + if (s == 6) + return "Validation | Performance"; + if (s == 5) + return "General | Performance"; + if (s == 4 /*VK_DEBUG_UTILS_MESSAGE_TYPE_PERFORMANCE_BIT_EXT*/) + return "Performance"; + if (s == 3) + return "General | Validation"; + if (s == 2 /*VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT*/) + return "Validation"; + if (s == 1 /*VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT*/) + return "General"; return "Unknown"; } -VkResult create_debug_utils_messenger(VkInstance instance, +VkResult create_debug_utils_messenger(VkInstance instance, PFN_vkDebugUtilsMessengerCallbackEXT debug_callback, - VkDebugUtilsMessageSeverityFlagsEXT severity, - VkDebugUtilsMessageTypeFlagsEXT type, - void* user_data_pointer, - VkDebugUtilsMessengerEXT* pDebugMessenger, - VkAllocationCallbacks* allocation_callbacks) { + VkDebugUtilsMessageSeverityFlagsEXT severity, + VkDebugUtilsMessageTypeFlagsEXT type, + void* user_data_pointer, + VkDebugUtilsMessengerEXT* pDebugMessenger, + VkAllocationCallbacks* allocation_callbacks) +{ - if (debug_callback == nullptr) debug_callback = default_debug_callback; + if (debug_callback == nullptr) + debug_callback = default_debug_callback; VkDebugUtilsMessengerCreateInfoEXT messengerCreateInfo = {}; - messengerCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; - messengerCreateInfo.pNext = nullptr; - messengerCreateInfo.messageSeverity = severity; - messengerCreateInfo.messageType = type; - messengerCreateInfo.pfnUserCallback = debug_callback; - messengerCreateInfo.pUserData = user_data_pointer; - - if (detail::vulkan_functions().fp_vkCreateDebugUtilsMessengerEXT != nullptr) { + messengerCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; + messengerCreateInfo.pNext = nullptr; + messengerCreateInfo.messageSeverity = severity; + messengerCreateInfo.messageType = type; + messengerCreateInfo.pfnUserCallback = debug_callback; + messengerCreateInfo.pUserData = user_data_pointer; + + if (detail::vulkan_functions().fp_vkCreateDebugUtilsMessengerEXT != nullptr) + { return detail::vulkan_functions().fp_vkCreateDebugUtilsMessengerEXT( instance, &messengerCreateInfo, allocation_callbacks, pDebugMessenger); - } else { + } + else + { return VK_ERROR_EXTENSION_NOT_PRESENT; } } -void destroy_debug_utils_messenger( - VkInstance instance, VkDebugUtilsMessengerEXT debugMessenger, VkAllocationCallbacks* allocation_callbacks) { +void destroy_debug_utils_messenger(VkInstance instance, + VkDebugUtilsMessengerEXT debugMessenger, + VkAllocationCallbacks* allocation_callbacks) +{ - if (detail::vulkan_functions().fp_vkDestroyDebugUtilsMessengerEXT != nullptr) { + if (detail::vulkan_functions().fp_vkDestroyDebugUtilsMessengerEXT != nullptr) + { detail::vulkan_functions().fp_vkDestroyDebugUtilsMessengerEXT(instance, debugMessenger, allocation_callbacks); } } GFXRECON_BEGIN_NAMESPACE(detail) -bool check_layer_supported(std::vector const& available_layers, const char* layer_name) { - if (!layer_name) return false; - for (const auto& layer_properties : available_layers) { - if (strcmp(layer_name, layer_properties.layerName) == 0) { +bool check_layer_supported(std::vector const& available_layers, const char* layer_name) +{ + if (!layer_name) + return false; + for (const auto& layer_properties : available_layers) + { + if (strcmp(layer_name, layer_properties.layerName) == 0) + { return true; } } return false; } -bool check_layers_supported(std::vector const& available_layers, std::vector const& layer_names) { +bool check_layers_supported(std::vector const& available_layers, + std::vector const& layer_names) +{ bool all_found = true; - for (const auto& layer_name : layer_names) { + for (const auto& layer_name : layer_names) + { bool found = check_layer_supported(available_layers, layer_name); - if (!found) all_found = false; + if (!found) + all_found = false; } return all_found; } -bool check_extension_supported(std::vector const& available_extensions, const char* extension_name) { - if (!extension_name) return false; - for (const auto& extension_properties : available_extensions) { - if (strcmp(extension_name, extension_properties.extensionName) == 0) { +bool check_extension_supported(std::vector const& available_extensions, + const char* extension_name) +{ + if (!extension_name) + return false; + for (const auto& extension_properties : available_extensions) + { + if (strcmp(extension_name, extension_properties.extensionName) == 0) + { return true; } } return false; } -bool check_extensions_supported( - std::vector const& available_extensions, std::vector const& extension_names) { +bool check_extensions_supported(std::vector const& available_extensions, + std::vector const& extension_names) +{ bool all_found = true; - for (const auto& extension_name : extension_names) { + for (const auto& extension_name : extension_names) + { bool found = check_extension_supported(available_extensions, extension_name); - if (!found) all_found = false; + if (!found) + all_found = false; } return all_found; } -template void setup_pNext_chain(T& structure, std::vector const& structs) { +template +void setup_pNext_chain(T& structure, std::vector const& structs) +{ structure.pNext = nullptr; - if (structs.size() <= 0) return; - for (size_t i = 0; i < structs.size() - 1; i++) { + if (structs.size() <= 0) + return; + for (size_t i = 0; i < structs.size() - 1; i++) + { structs.at(i)->pNext = structs.at(i + 1); } structure.pNext = structs.at(0); @@ -396,12 +487,14 @@ const char* validation_layer_name = "VK_LAYER_KHRONOS_validation"; GFXRECON_END_NAMESPACE(detail) -#define CASE_TO_STRING(CATEGORY, TYPE) \ - case CATEGORY::TYPE: \ +#define CASE_TO_STRING(CATEGORY, TYPE) \ + case CATEGORY::TYPE: \ return #TYPE; -const char* to_string(InstanceError err) { - switch (err) { +const char* to_string(InstanceError err) +{ + switch (err) + { CASE_TO_STRING(InstanceError, vulkan_unavailable) CASE_TO_STRING(InstanceError, vulkan_version_unavailable) CASE_TO_STRING(InstanceError, vulkan_version_1_1_unavailable) @@ -415,8 +508,10 @@ const char* to_string(InstanceError err) { return ""; } } -const char* to_string(PhysicalDeviceError err) { - switch (err) { +const char* to_string(PhysicalDeviceError err) +{ + switch (err) + { CASE_TO_STRING(PhysicalDeviceError, no_surface_provided) CASE_TO_STRING(PhysicalDeviceError, failed_enumerate_physical_devices) CASE_TO_STRING(PhysicalDeviceError, no_physical_devices_found) @@ -425,8 +520,10 @@ const char* to_string(PhysicalDeviceError err) { return ""; } } -const char* to_string(QueueError err) { - switch (err) { +const char* to_string(QueueError err) +{ + switch (err) + { CASE_TO_STRING(QueueError, present_unavailable) CASE_TO_STRING(QueueError, graphics_unavailable) CASE_TO_STRING(QueueError, compute_unavailable) @@ -437,15 +534,19 @@ const char* to_string(QueueError err) { return ""; } } -const char* to_string(DeviceError err) { - switch (err) { +const char* to_string(DeviceError err) +{ + switch (err) + { CASE_TO_STRING(DeviceError, failed_create_device) default: return ""; } } -const char* to_string(SwapchainError err) { - switch (err) { +const char* to_string(SwapchainError err) +{ + switch (err) + { CASE_TO_STRING(SwapchainError, surface_handle_not_provided) CASE_TO_STRING(SwapchainError, failed_query_surface_support_details) CASE_TO_STRING(SwapchainError, failed_create_swapchain) @@ -458,10 +559,12 @@ const char* to_string(SwapchainError err) { } } -std::exception to_exception(InstanceError error) { +std::exception to_exception(InstanceError error) +{ return std::runtime_error(to_string(error)); } -std::exception to_exception(InstanceError error, VkResult result) { +std::exception to_exception(InstanceError error, VkResult result) +{ std::string message{}; message.append(to_string(error)); message.append(": "); @@ -469,10 +572,12 @@ std::exception to_exception(InstanceError error, VkResult result) { return std::runtime_error(message); } -std::exception to_exception(PhysicalDeviceError error) { +std::exception to_exception(PhysicalDeviceError error) +{ return std::runtime_error(to_string(error)); } -std::exception to_exception(PhysicalDeviceError error, VkResult result) { +std::exception to_exception(PhysicalDeviceError error, VkResult result) +{ std::string message{}; message.append(to_string(error)); message.append(": "); @@ -480,10 +585,12 @@ std::exception to_exception(PhysicalDeviceError error, VkResult result) { return std::runtime_error(message); } -std::exception to_exception(QueueError error) { +std::exception to_exception(QueueError error) +{ return std::runtime_error(to_string(error)); } -std::exception to_exception(QueueError error, VkResult result) { +std::exception to_exception(QueueError error, VkResult result) +{ std::string message{}; message.append(to_string(error)); message.append(": "); @@ -491,10 +598,12 @@ std::exception to_exception(QueueError error, VkResult result) { return std::runtime_error(message); } -std::exception to_exception(DeviceError error) { +std::exception to_exception(DeviceError error) +{ return std::runtime_error(to_string(error)); } -std::exception to_exception(DeviceError error, VkResult result) { +std::exception to_exception(DeviceError error, VkResult result) +{ std::string message{}; message.append(to_string(error)); message.append(": "); @@ -502,10 +611,12 @@ std::exception to_exception(DeviceError error, VkResult result) { return std::runtime_error(message); } -std::exception to_exception(SwapchainError error) { +std::exception to_exception(SwapchainError error) +{ return std::runtime_error(to_string(error)); } -std::exception to_exception(SwapchainError error, VkResult result) { +std::exception to_exception(SwapchainError error, VkResult result) +{ std::string message{}; message.append(to_string(error)); message.append(": "); @@ -513,111 +624,147 @@ std::exception to_exception(SwapchainError error, VkResult result) { return std::runtime_error(message); } -SystemInfo SystemInfo::get_system_info() { - if (!detail::vulkan_functions().init_vulkan_funcs(nullptr)) { +SystemInfo SystemInfo::get_system_info() +{ + if (!detail::vulkan_functions().init_vulkan_funcs(nullptr)) + { throw to_exception(InstanceError::vulkan_unavailable); } return SystemInfo(); } -SystemInfo SystemInfo::get_system_info(PFN_vkGetInstanceProcAddr fp_vkGetInstanceProcAddr) { +SystemInfo SystemInfo::get_system_info(PFN_vkGetInstanceProcAddr fp_vkGetInstanceProcAddr) +{ // Using externally provided function pointers, assume the loader is available - if (!detail::vulkan_functions().init_vulkan_funcs(fp_vkGetInstanceProcAddr)) { + if (!detail::vulkan_functions().init_vulkan_funcs(fp_vkGetInstanceProcAddr)) + { throw to_exception(InstanceError::vulkan_unavailable); } return SystemInfo(); } -SystemInfo::SystemInfo() { +SystemInfo::SystemInfo() +{ auto available_layers_ret = detail::get_vector( this->available_layers, detail::vulkan_functions().fp_vkEnumerateInstanceLayerProperties); - if (available_layers_ret != VK_SUCCESS) { + if (available_layers_ret != VK_SUCCESS) + { this->available_layers.clear(); } for (auto& layer : this->available_layers) - if (strcmp(layer.layerName, detail::validation_layer_name) == 0) validation_layers_available = true; + if (strcmp(layer.layerName, detail::validation_layer_name) == 0) + validation_layers_available = true; auto available_extensions_ret = detail::get_vector( this->available_extensions, detail::vulkan_functions().fp_vkEnumerateInstanceExtensionProperties, nullptr); - if (available_extensions_ret != VK_SUCCESS) { + if (available_extensions_ret != VK_SUCCESS) + { this->available_extensions.clear(); } - for (auto& ext : this->available_extensions) { - if (strcmp(ext.extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME) == 0) { + for (auto& ext : this->available_extensions) + { + if (strcmp(ext.extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME) == 0) + { debug_utils_available = true; } } - for (auto& layer : this->available_layers) { + for (auto& layer : this->available_layers) + { std::vector layer_extensions; - auto layer_extensions_ret = detail::get_vector( + auto layer_extensions_ret = detail::get_vector( layer_extensions, detail::vulkan_functions().fp_vkEnumerateInstanceExtensionProperties, layer.layerName); - if (layer_extensions_ret == VK_SUCCESS) { + if (layer_extensions_ret == VK_SUCCESS) + { this->available_extensions.insert( this->available_extensions.end(), layer_extensions.begin(), layer_extensions.end()); - for (auto& ext : layer_extensions) { - if (strcmp(ext.extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME) == 0) { + for (auto& ext : layer_extensions) + { + if (strcmp(ext.extensionName, VK_EXT_DEBUG_UTILS_EXTENSION_NAME) == 0) + { debug_utils_available = true; } } } } } -bool SystemInfo::is_extension_available(const char* extension_name) const { - if (!extension_name) return false; +bool SystemInfo::is_extension_available(const char* extension_name) const +{ + if (!extension_name) + return false; return detail::check_extension_supported(available_extensions, extension_name); } -bool SystemInfo::is_layer_available(const char* layer_name) const { - if (!layer_name) return false; +bool SystemInfo::is_layer_available(const char* layer_name) const +{ + if (!layer_name) + return false; return detail::check_layer_supported(available_layers, layer_name); } -void destroy_surface(Instance const& instance, VkSurfaceKHR surface) { - if (instance.instance != VK_NULL_HANDLE && surface != VK_NULL_HANDLE) { +void destroy_surface(Instance const& instance, VkSurfaceKHR surface) +{ + if (instance.instance != VK_NULL_HANDLE && surface != VK_NULL_HANDLE) + { detail::vulkan_functions().fp_vkDestroySurfaceKHR(instance.instance, surface, instance.allocation_callbacks); } } -void destroy_surface(VkInstance instance, VkSurfaceKHR surface, VkAllocationCallbacks* callbacks) { - if (instance != VK_NULL_HANDLE && surface != VK_NULL_HANDLE) { +void destroy_surface(VkInstance instance, VkSurfaceKHR surface, VkAllocationCallbacks* callbacks) +{ + if (instance != VK_NULL_HANDLE && surface != VK_NULL_HANDLE) + { detail::vulkan_functions().fp_vkDestroySurfaceKHR(instance, surface, callbacks); } } -void destroy_instance(Instance const& instance) { - if (instance.instance != VK_NULL_HANDLE) { +void destroy_instance(Instance const& instance) +{ + if (instance.instance != VK_NULL_HANDLE) + { if (instance.debug_messenger != VK_NULL_HANDLE) destroy_debug_utils_messenger(instance.instance, instance.debug_messenger, instance.allocation_callbacks); detail::vulkan_functions().fp_vkDestroyInstance(instance.instance, instance.allocation_callbacks); } } -Instance::operator VkInstance() const { return this->instance; } +Instance::operator VkInstance() const +{ + return this->instance; +} -vkb::InstanceDispatchTable Instance::make_table() const { return { instance, fp_vkGetInstanceProcAddr }; } +vkb::InstanceDispatchTable Instance::make_table() const +{ + return { instance, fp_vkGetInstanceProcAddr }; +} -InstanceBuilder::InstanceBuilder(PFN_vkGetInstanceProcAddr fp_vkGetInstanceProcAddr) { +InstanceBuilder::InstanceBuilder(PFN_vkGetInstanceProcAddr fp_vkGetInstanceProcAddr) +{ info.fp_vkGetInstanceProcAddr = fp_vkGetInstanceProcAddr; } InstanceBuilder::InstanceBuilder() {} -Instance InstanceBuilder::build() const { +Instance InstanceBuilder::build() const +{ auto system = SystemInfo::get_system_info(info.fp_vkGetInstanceProcAddr); uint32_t instance_version = VKB_VK_API_VERSION_1_0; if (info.minimum_instance_version > VKB_VK_API_VERSION_1_0 || info.required_api_version > VKB_VK_API_VERSION_1_0 || - info.desired_api_version > VKB_VK_API_VERSION_1_0) { - PFN_vkEnumerateInstanceVersion pfn_vkEnumerateInstanceVersion = detail::vulkan_functions().fp_vkEnumerateInstanceVersion; + info.desired_api_version > VKB_VK_API_VERSION_1_0) + { + PFN_vkEnumerateInstanceVersion pfn_vkEnumerateInstanceVersion = + detail::vulkan_functions().fp_vkEnumerateInstanceVersion; - if (pfn_vkEnumerateInstanceVersion != nullptr) { + if (pfn_vkEnumerateInstanceVersion != nullptr) + { VkResult res = pfn_vkEnumerateInstanceVersion(&instance_version); // Should always return VK_SUCCESS if (res != VK_SUCCESS && info.required_api_version > 0) throw to_exception(InstanceError::vulkan_version_unavailable); } if (pfn_vkEnumerateInstanceVersion == nullptr || instance_version < info.minimum_instance_version || - (info.minimum_instance_version == 0 && instance_version < info.required_api_version)) { + (info.minimum_instance_version == 0 && instance_version < info.required_api_version)) + { if (VK_VERSION_MINOR(info.required_api_version) == 2) throw to_exception(InstanceError::vulkan_version_1_2_unavailable); else if (VK_VERSION_MINOR(info.required_api_version)) @@ -629,47 +776,53 @@ Instance InstanceBuilder::build() const { uint32_t api_version = instance_version < VKB_VK_API_VERSION_1_1 ? instance_version : info.required_api_version; - if (info.desired_api_version > VKB_VK_API_VERSION_1_0 && instance_version >= info.desired_api_version) { + if (info.desired_api_version > VKB_VK_API_VERSION_1_0 && instance_version >= info.desired_api_version) + { instance_version = info.desired_api_version; - api_version = info.desired_api_version; + api_version = info.desired_api_version; } - VkApplicationInfo app_info = {}; - app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; - app_info.pNext = nullptr; - app_info.pApplicationName = info.app_name != nullptr ? info.app_name : ""; + VkApplicationInfo app_info = {}; + app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO; + app_info.pNext = nullptr; + app_info.pApplicationName = info.app_name != nullptr ? info.app_name : ""; app_info.applicationVersion = info.application_version; - app_info.pEngineName = info.engine_name != nullptr ? info.engine_name : ""; - app_info.engineVersion = info.engine_version; - app_info.apiVersion = api_version; + app_info.pEngineName = info.engine_name != nullptr ? info.engine_name : ""; + app_info.engineVersion = info.engine_version; + app_info.apiVersion = api_version; std::vector extensions; std::vector layers; - for (auto& ext : info.extensions) - extensions.push_back(ext); - if (info.debug_callback != nullptr && info.use_debug_messenger && system.debug_utils_available) { + for (auto& ext : info.extensions) extensions.push_back(ext); + if (info.debug_callback != nullptr && info.use_debug_messenger && system.debug_utils_available) + { extensions.push_back(VK_EXT_DEBUG_UTILS_EXTENSION_NAME); } bool properties2_ext_enabled = - api_version < VKB_VK_API_VERSION_1_1 && detail::check_extension_supported(system.available_extensions, - VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); - if (properties2_ext_enabled) { + api_version < VKB_VK_API_VERSION_1_1 && + detail::check_extension_supported(system.available_extensions, + VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); + if (properties2_ext_enabled) + { extensions.push_back(VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME); } #if defined(VK_KHR_portability_enumeration) bool portability_enumeration_support = detail::check_extension_supported(system.available_extensions, VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME); - if (portability_enumeration_support) { + if (portability_enumeration_support) + { extensions.push_back(VK_KHR_PORTABILITY_ENUMERATION_EXTENSION_NAME); } #else bool portability_enumeration_support = false; #endif - if (!info.headless_context) { + if (!info.headless_context) + { auto check_add_window_ext = [&](const char* name) -> bool { - if (!detail::check_extension_supported(system.available_extensions, name)) return false; + if (!detail::check_extension_supported(system.available_extensions, name)) + return false; extensions.push_back(name); return true; }; @@ -683,8 +836,8 @@ Instance InstanceBuilder::build() const { #elif defined(__linux__) // make sure all three calls to check_add_window_ext, don't allow short circuiting bool added_window_exts = check_add_window_ext("VK_KHR_xcb_surface"); - added_window_exts = check_add_window_ext("VK_KHR_xlib_surface") || added_window_exts; - added_window_exts = check_add_window_ext("VK_KHR_wayland_surface") || added_window_exts; + added_window_exts = check_add_window_ext("VK_KHR_xlib_surface") || added_window_exts; + added_window_exts = check_add_window_ext("VK_KHR_wayland_surface") || added_window_exts; #elif defined(__APPLE__) bool added_window_exts = check_add_window_ext("VK_EXT_metal_surface"); #endif @@ -692,82 +845,91 @@ Instance InstanceBuilder::build() const { throw to_exception(InstanceError::windowing_extensions_not_present); } bool all_extensions_supported = detail::check_extensions_supported(system.available_extensions, extensions); - if (!all_extensions_supported) { + if (!all_extensions_supported) + { throw to_exception(InstanceError::requested_extensions_not_present); } - for (auto& layer : info.layers) - layers.push_back(layer); + for (auto& layer : info.layers) layers.push_back(layer); - if (info.enable_validation_layers || (info.request_validation_layers && system.validation_layers_available)) { + if (info.enable_validation_layers || (info.request_validation_layers && system.validation_layers_available)) + { layers.push_back(detail::validation_layer_name); } bool all_layers_supported = detail::check_layers_supported(system.available_layers, layers); - if (!all_layers_supported) { + if (!all_layers_supported) + { throw to_exception(InstanceError::requested_layers_not_present); } std::vector pNext_chain; VkDebugUtilsMessengerCreateInfoEXT messengerCreateInfo = {}; - if (info.use_debug_messenger) { - messengerCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; - messengerCreateInfo.pNext = nullptr; + if (info.use_debug_messenger) + { + messengerCreateInfo.sType = VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT; + messengerCreateInfo.pNext = nullptr; messengerCreateInfo.messageSeverity = info.debug_message_severity; - messengerCreateInfo.messageType = info.debug_message_type; + messengerCreateInfo.messageType = info.debug_message_type; messengerCreateInfo.pfnUserCallback = info.debug_callback; - messengerCreateInfo.pUserData = info.debug_user_data_pointer; + messengerCreateInfo.pUserData = info.debug_user_data_pointer; pNext_chain.push_back(reinterpret_cast(&messengerCreateInfo)); } VkValidationFeaturesEXT features{}; - if (info.enabled_validation_features.size() != 0 || info.disabled_validation_features.size()) { - features.sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT; - features.pNext = nullptr; - features.enabledValidationFeatureCount = static_cast(info.enabled_validation_features.size()); - features.pEnabledValidationFeatures = info.enabled_validation_features.data(); + if (info.enabled_validation_features.size() != 0 || info.disabled_validation_features.size()) + { + features.sType = VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT; + features.pNext = nullptr; + features.enabledValidationFeatureCount = static_cast(info.enabled_validation_features.size()); + features.pEnabledValidationFeatures = info.enabled_validation_features.data(); features.disabledValidationFeatureCount = static_cast(info.disabled_validation_features.size()); - features.pDisabledValidationFeatures = info.disabled_validation_features.data(); + features.pDisabledValidationFeatures = info.disabled_validation_features.data(); pNext_chain.push_back(reinterpret_cast(&features)); } VkValidationFlagsEXT checks{}; - if (info.disabled_validation_checks.size() != 0) { - checks.sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT; - checks.pNext = nullptr; + if (info.disabled_validation_checks.size() != 0) + { + checks.sType = VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT; + checks.pNext = nullptr; checks.disabledValidationCheckCount = static_cast(info.disabled_validation_checks.size()); - checks.pDisabledValidationChecks = info.disabled_validation_checks.data(); + checks.pDisabledValidationChecks = info.disabled_validation_checks.data(); pNext_chain.push_back(reinterpret_cast(&checks)); } VkInstanceCreateInfo instance_create_info = {}; - instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; + instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO; detail::setup_pNext_chain(instance_create_info, pNext_chain); #if !defined(NDEBUG) - for (auto& node : pNext_chain) { + for (auto& node : pNext_chain) + { assert(node->sType != VK_STRUCTURE_TYPE_APPLICATION_INFO); } #endif - instance_create_info.flags = info.flags; - instance_create_info.pApplicationInfo = &app_info; - instance_create_info.enabledExtensionCount = static_cast(extensions.size()); + instance_create_info.flags = info.flags; + instance_create_info.pApplicationInfo = &app_info; + instance_create_info.enabledExtensionCount = static_cast(extensions.size()); instance_create_info.ppEnabledExtensionNames = extensions.data(); - instance_create_info.enabledLayerCount = static_cast(layers.size()); - instance_create_info.ppEnabledLayerNames = layers.data(); + instance_create_info.enabledLayerCount = static_cast(layers.size()); + instance_create_info.ppEnabledLayerNames = layers.data(); #if defined(VK_KHR_portability_enumeration) - if (portability_enumeration_support) { + if (portability_enumeration_support) + { instance_create_info.flags |= VK_INSTANCE_CREATE_ENUMERATE_PORTABILITY_BIT_KHR; } #endif Instance instance; - VkResult res = - detail::vulkan_functions().fp_vkCreateInstance(&instance_create_info, info.allocation_callbacks, &instance.instance); - if (res != VK_SUCCESS) throw to_exception(InstanceError::failed_create_instance, res); + VkResult res = detail::vulkan_functions().fp_vkCreateInstance( + &instance_create_info, info.allocation_callbacks, &instance.instance); + if (res != VK_SUCCESS) + throw to_exception(InstanceError::failed_create_instance, res); detail::vulkan_functions().init_instance_funcs(instance.instance); - if (info.use_debug_messenger) { + if (info.use_debug_messenger) + { res = create_debug_utils_messenger(instance.instance, info.debug_callback, info.debug_message_severity, @@ -775,165 +937,206 @@ Instance InstanceBuilder::build() const { info.debug_user_data_pointer, &instance.debug_messenger, info.allocation_callbacks); - if (res != VK_SUCCESS) throw to_exception(InstanceError::failed_create_debug_messenger, res); + if (res != VK_SUCCESS) + throw to_exception(InstanceError::failed_create_debug_messenger, res); } - instance.headless = info.headless_context; - instance.properties2_ext_enabled = properties2_ext_enabled; - instance.allocation_callbacks = info.allocation_callbacks; - instance.instance_version = instance_version; - instance.api_version = api_version; + instance.headless = info.headless_context; + instance.properties2_ext_enabled = properties2_ext_enabled; + instance.allocation_callbacks = info.allocation_callbacks; + instance.instance_version = instance_version; + instance.api_version = api_version; instance.fp_vkGetInstanceProcAddr = detail::vulkan_functions().ptr_vkGetInstanceProcAddr; - instance.fp_vkGetDeviceProcAddr = detail::vulkan_functions().fp_vkGetDeviceProcAddr; + instance.fp_vkGetDeviceProcAddr = detail::vulkan_functions().fp_vkGetDeviceProcAddr; return instance; } -InstanceBuilder& InstanceBuilder::set_app_name(const char* app_name) { - if (!app_name) return *this; +InstanceBuilder& InstanceBuilder::set_app_name(const char* app_name) +{ + if (!app_name) + return *this; info.app_name = app_name; return *this; } -InstanceBuilder& InstanceBuilder::set_engine_name(const char* engine_name) { - if (!engine_name) return *this; +InstanceBuilder& InstanceBuilder::set_engine_name(const char* engine_name) +{ + if (!engine_name) + return *this; info.engine_name = engine_name; return *this; } -InstanceBuilder& InstanceBuilder::set_app_version(uint32_t app_version) { +InstanceBuilder& InstanceBuilder::set_app_version(uint32_t app_version) +{ info.application_version = app_version; return *this; } -InstanceBuilder& InstanceBuilder::set_app_version(uint32_t major, uint32_t minor, uint32_t patch) { +InstanceBuilder& InstanceBuilder::set_app_version(uint32_t major, uint32_t minor, uint32_t patch) +{ info.application_version = VKB_MAKE_VK_VERSION(0, major, minor, patch); return *this; } -InstanceBuilder& InstanceBuilder::set_engine_version(uint32_t engine_version) { +InstanceBuilder& InstanceBuilder::set_engine_version(uint32_t engine_version) +{ info.engine_version = engine_version; return *this; } -InstanceBuilder& InstanceBuilder::set_engine_version(uint32_t major, uint32_t minor, uint32_t patch) { +InstanceBuilder& InstanceBuilder::set_engine_version(uint32_t major, uint32_t minor, uint32_t patch) +{ info.engine_version = VKB_MAKE_VK_VERSION(0, major, minor, patch); return *this; } -InstanceBuilder& InstanceBuilder::require_api_version(uint32_t required_api_version) { +InstanceBuilder& InstanceBuilder::require_api_version(uint32_t required_api_version) +{ info.required_api_version = required_api_version; return *this; } -InstanceBuilder& InstanceBuilder::require_api_version(uint32_t major, uint32_t minor, uint32_t patch) { +InstanceBuilder& InstanceBuilder::require_api_version(uint32_t major, uint32_t minor, uint32_t patch) +{ info.required_api_version = VKB_MAKE_VK_VERSION(0, major, minor, patch); return *this; } -InstanceBuilder& InstanceBuilder::set_minimum_instance_version(uint32_t minimum_instance_version) { +InstanceBuilder& InstanceBuilder::set_minimum_instance_version(uint32_t minimum_instance_version) +{ info.minimum_instance_version = minimum_instance_version; return *this; } -InstanceBuilder& InstanceBuilder::set_minimum_instance_version(uint32_t major, uint32_t minor, uint32_t patch) { +InstanceBuilder& InstanceBuilder::set_minimum_instance_version(uint32_t major, uint32_t minor, uint32_t patch) +{ info.minimum_instance_version = VKB_MAKE_VK_VERSION(0, major, minor, patch); return *this; } -InstanceBuilder& InstanceBuilder::desire_api_version(uint32_t preferred_vulkan_version) { +InstanceBuilder& InstanceBuilder::desire_api_version(uint32_t preferred_vulkan_version) +{ info.desired_api_version = preferred_vulkan_version; return *this; } -InstanceBuilder& InstanceBuilder::desire_api_version(uint32_t major, uint32_t minor, uint32_t patch) { +InstanceBuilder& InstanceBuilder::desire_api_version(uint32_t major, uint32_t minor, uint32_t patch) +{ info.desired_api_version = VKB_MAKE_VK_VERSION(0, major, minor, patch); return *this; } -InstanceBuilder& InstanceBuilder::enable_layer(const char* layer_name) { - if (!layer_name) return *this; +InstanceBuilder& InstanceBuilder::enable_layer(const char* layer_name) +{ + if (!layer_name) + return *this; info.layers.push_back(layer_name); return *this; } -InstanceBuilder& InstanceBuilder::enable_extension(const char* extension_name) { - if (!extension_name) return *this; +InstanceBuilder& InstanceBuilder::enable_extension(const char* extension_name) +{ + if (!extension_name) + return *this; info.extensions.push_back(extension_name); return *this; } -InstanceBuilder& InstanceBuilder::enable_extensions(std::vector const& extensions) { - for (const auto extension : extensions) { +InstanceBuilder& InstanceBuilder::enable_extensions(std::vector const& extensions) +{ + for (const auto extension : extensions) + { info.extensions.push_back(extension); } return *this; } -InstanceBuilder& InstanceBuilder::enable_extensions(size_t count, const char* const* extensions) { - if (!extensions || count == 0) return *this; - for (size_t i = 0; i < count; i++) { +InstanceBuilder& InstanceBuilder::enable_extensions(size_t count, const char* const* extensions) +{ + if (!extensions || count == 0) + return *this; + for (size_t i = 0; i < count; i++) + { info.extensions.push_back(extensions[i]); } return *this; } -InstanceBuilder& InstanceBuilder::enable_validation_layers(bool enable_validation) { +InstanceBuilder& InstanceBuilder::enable_validation_layers(bool enable_validation) +{ info.enable_validation_layers = enable_validation; return *this; } -InstanceBuilder& InstanceBuilder::request_validation_layers(bool enable_validation) { +InstanceBuilder& InstanceBuilder::request_validation_layers(bool enable_validation) +{ info.request_validation_layers = enable_validation; return *this; } -InstanceBuilder& InstanceBuilder::use_default_debug_messenger() { +InstanceBuilder& InstanceBuilder::use_default_debug_messenger() +{ info.use_debug_messenger = true; - info.debug_callback = default_debug_callback; + info.debug_callback = default_debug_callback; return *this; } -InstanceBuilder& InstanceBuilder::set_debug_callback(PFN_vkDebugUtilsMessengerCallbackEXT callback) { +InstanceBuilder& InstanceBuilder::set_debug_callback(PFN_vkDebugUtilsMessengerCallbackEXT callback) +{ info.use_debug_messenger = true; - info.debug_callback = callback; + info.debug_callback = callback; return *this; } -InstanceBuilder& InstanceBuilder::set_debug_callback_user_data_pointer(void* user_data_pointer) { +InstanceBuilder& InstanceBuilder::set_debug_callback_user_data_pointer(void* user_data_pointer) +{ info.debug_user_data_pointer = user_data_pointer; return *this; } -InstanceBuilder& InstanceBuilder::set_headless(bool headless) { +InstanceBuilder& InstanceBuilder::set_headless(bool headless) +{ info.headless_context = headless; return *this; } -InstanceBuilder& InstanceBuilder::set_debug_messenger_severity(VkDebugUtilsMessageSeverityFlagsEXT severity) { +InstanceBuilder& InstanceBuilder::set_debug_messenger_severity(VkDebugUtilsMessageSeverityFlagsEXT severity) +{ info.debug_message_severity = severity; return *this; } -InstanceBuilder& InstanceBuilder::add_debug_messenger_severity(VkDebugUtilsMessageSeverityFlagsEXT severity) { +InstanceBuilder& InstanceBuilder::add_debug_messenger_severity(VkDebugUtilsMessageSeverityFlagsEXT severity) +{ info.debug_message_severity = info.debug_message_severity | severity; return *this; } -InstanceBuilder& InstanceBuilder::set_debug_messenger_type(VkDebugUtilsMessageTypeFlagsEXT type) { +InstanceBuilder& InstanceBuilder::set_debug_messenger_type(VkDebugUtilsMessageTypeFlagsEXT type) +{ info.debug_message_type = type; return *this; } -InstanceBuilder& InstanceBuilder::add_debug_messenger_type(VkDebugUtilsMessageTypeFlagsEXT type) { +InstanceBuilder& InstanceBuilder::add_debug_messenger_type(VkDebugUtilsMessageTypeFlagsEXT type) +{ info.debug_message_type = info.debug_message_type | type; return *this; } -InstanceBuilder& InstanceBuilder::add_validation_disable(VkValidationCheckEXT check) { +InstanceBuilder& InstanceBuilder::add_validation_disable(VkValidationCheckEXT check) +{ info.disabled_validation_checks.push_back(check); return *this; } -InstanceBuilder& InstanceBuilder::add_validation_feature_enable(VkValidationFeatureEnableEXT enable) { +InstanceBuilder& InstanceBuilder::add_validation_feature_enable(VkValidationFeatureEnableEXT enable) +{ info.enabled_validation_features.push_back(enable); return *this; } -InstanceBuilder& InstanceBuilder::add_validation_feature_disable(VkValidationFeatureDisableEXT disable) { +InstanceBuilder& InstanceBuilder::add_validation_feature_disable(VkValidationFeatureDisableEXT disable) +{ info.disabled_validation_features.push_back(disable); return *this; } -InstanceBuilder& InstanceBuilder::set_allocation_callbacks(VkAllocationCallbacks* callbacks) { +InstanceBuilder& InstanceBuilder::set_allocation_callbacks(VkAllocationCallbacks* callbacks) +{ info.allocation_callbacks = callbacks; return *this; } void destroy_debug_messenger(VkInstance const instance, VkDebugUtilsMessengerEXT const messenger); - // ---- Physical Device ---- // GFXRECON_BEGIN_NAMESPACE(detail) -std::vector check_device_extension_support( - std::vector const& available_extensions, std::vector const& desired_extensions) { +std::vector check_device_extension_support(std::vector const& available_extensions, + std::vector const& desired_extensions) +{ std::vector extensions_to_enable; - for (const auto& avail_ext : available_extensions) { - for (auto& req_ext : desired_extensions) { - if (avail_ext == req_ext) { + for (const auto& avail_ext : available_extensions) + { + for (auto& req_ext : desired_extensions) + { + if (avail_ext == req_ext) + { extensions_to_enable.push_back(req_ext); break; } @@ -1066,22 +1269,34 @@ bool supports_features(const VkPhysicalDeviceFeatures& supported, } // clang-format on // Finds the first queue which supports the desired operations. -std::optional get_first_queue_index(std::vector const& families, VkQueueFlags desired_flags) { - for (uint32_t i = 0; i < static_cast(families.size()); i++) { - if ((families[i].queueFlags & desired_flags) == desired_flags) return i; +std::optional get_first_queue_index(std::vector const& families, + VkQueueFlags desired_flags) +{ + for (uint32_t i = 0; i < static_cast(families.size()); i++) + { + if ((families[i].queueFlags & desired_flags) == desired_flags) + return i; } return {}; } // Finds the queue which is separate from the graphics queue and has the desired flag and not the // undesired flag, but will select it if no better options are available compute support. -std::optional get_separate_queue_index( - std::vector const& families, VkQueueFlags desired_flags, VkQueueFlags undesired_flags) { +std::optional get_separate_queue_index(std::vector const& families, + VkQueueFlags desired_flags, + VkQueueFlags undesired_flags) +{ std::optional index = {}; - for (uint32_t i = 0; i < static_cast(families.size()); i++) { - if ((families[i].queueFlags & desired_flags) == desired_flags && ((families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0)) { - if ((families[i].queueFlags & undesired_flags) == 0) { + for (uint32_t i = 0; i < static_cast(families.size()); i++) + { + if ((families[i].queueFlags & desired_flags) == desired_flags && + ((families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0)) + { + if ((families[i].queueFlags & undesired_flags) == 0) + { return i; - } else { + } + else + { index = i; } } @@ -1090,9 +1305,12 @@ std::optional get_separate_queue_index( } // finds the first queue which supports only the desired flag (not graphics or transfer). -std::optional get_dedicated_queue_index( - std::vector const& families, VkQueueFlags desired_flags, VkQueueFlags undesired_flags) { - for (uint32_t i = 0; i < static_cast(families.size()); i++) { +std::optional get_dedicated_queue_index(std::vector const& families, + VkQueueFlags desired_flags, + VkQueueFlags undesired_flags) +{ + for (uint32_t i = 0; i < static_cast(families.size()); i++) + { if ((families[i].queueFlags & desired_flags) == desired_flags && (families[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) == 0 && (families[i].queueFlags & undesired_flags) == 0) return i; @@ -1101,43 +1319,58 @@ std::optional get_dedicated_queue_index( } // finds the first queue which supports presenting. -std::optional get_present_queue_index( - VkPhysicalDevice const phys_device, VkSurfaceKHR const surface, std::vector const& families) { - for (uint32_t i = 0; i < static_cast(families.size()); i++) { +std::optional get_present_queue_index(VkPhysicalDevice const phys_device, + VkSurfaceKHR const surface, + std::vector const& families) +{ + for (uint32_t i = 0; i < static_cast(families.size()); i++) + { VkBool32 presentSupport = false; - if (surface != VK_NULL_HANDLE) { - VkResult res = detail::vulkan_functions().fp_vkGetPhysicalDeviceSurfaceSupportKHR(phys_device, i, surface, &presentSupport); - if (res != VK_SUCCESS) return {}; // TODO: determine if this should fail another way + if (surface != VK_NULL_HANDLE) + { + VkResult res = detail::vulkan_functions().fp_vkGetPhysicalDeviceSurfaceSupportKHR( + phys_device, i, surface, &presentSupport); + if (res != VK_SUCCESS) + return {}; // TODO: determine if this should fail another way } - if (presentSupport == VK_TRUE) return i; + if (presentSupport == VK_TRUE) + return i; } return {}; } GFXRECON_END_NAMESPACE(detail) -PhysicalDevice PhysicalDeviceSelector::populate_device_details( - VkPhysicalDevice vk_phys_device, detail::GenericFeatureChain const& src_extended_features_chain) const { +PhysicalDevice +PhysicalDeviceSelector::populate_device_details(VkPhysicalDevice vk_phys_device, + detail::GenericFeatureChain const& src_extended_features_chain) const +{ PhysicalDevice physical_device{}; - physical_device.physical_device = vk_phys_device; - physical_device.surface = instance_info.surface; + physical_device.physical_device = vk_phys_device; + physical_device.surface = instance_info.surface; physical_device.defer_surface_initialization = criteria.defer_surface_initialization; - physical_device.instance_version = instance_info.version; - auto queue_families = detail::get_vector_noerror( + physical_device.instance_version = instance_info.version; + auto queue_families = detail::get_vector_noerror( detail::vulkan_functions().fp_vkGetPhysicalDeviceQueueFamilyProperties, vk_phys_device); physical_device.queue_families = queue_families; detail::vulkan_functions().fp_vkGetPhysicalDeviceProperties(vk_phys_device, &physical_device.properties); detail::vulkan_functions().fp_vkGetPhysicalDeviceFeatures(vk_phys_device, &physical_device.features); - detail::vulkan_functions().fp_vkGetPhysicalDeviceMemoryProperties(vk_phys_device, &physical_device.memory_properties); + detail::vulkan_functions().fp_vkGetPhysicalDeviceMemoryProperties(vk_phys_device, + &physical_device.memory_properties); physical_device.name = physical_device.properties.deviceName; std::vector available_extensions; - auto available_extensions_ret = detail::get_vector( - available_extensions, detail::vulkan_functions().fp_vkEnumerateDeviceExtensionProperties, vk_phys_device, nullptr); - if (available_extensions_ret != VK_SUCCESS) return physical_device; - for (const auto& ext : available_extensions) { + auto available_extensions_ret = + detail::get_vector(available_extensions, + detail::vulkan_functions().fp_vkEnumerateDeviceExtensionProperties, + vk_phys_device, + nullptr); + if (available_extensions_ret != VK_SUCCESS) + return physical_device; + for (const auto& ext : available_extensions) + { physical_device.available_extensions.push_back(&ext.extensionName[0]); } @@ -1146,13 +1379,17 @@ PhysicalDevice PhysicalDeviceSelector::populate_device_details( auto fill_chain = src_extended_features_chain; bool instance_is_1_1 = instance_info.version >= VKB_VK_API_VERSION_1_1; - if (!fill_chain.nodes.empty() && (instance_is_1_1 || instance_info.properties2_ext_enabled)) { + if (!fill_chain.nodes.empty() && (instance_is_1_1 || instance_info.properties2_ext_enabled)) + { VkPhysicalDeviceFeatures2 local_features{}; fill_chain.chain_up(local_features); // Use KHR function if not able to use the core function - if (instance_is_1_1) { + if (instance_is_1_1) + { detail::vulkan_functions().fp_vkGetPhysicalDeviceFeatures2(vk_phys_device, &local_features); - } else { + } + else + { detail::vulkan_functions().fp_vkGetPhysicalDeviceFeatures2KHR(vk_phys_device, &local_features); } physical_device.extended_features_chain = fill_chain; @@ -1161,20 +1398,29 @@ PhysicalDevice PhysicalDeviceSelector::populate_device_details( return physical_device; } -PhysicalDevice::Suitable PhysicalDeviceSelector::is_device_suitable(PhysicalDevice const& pd) const { +PhysicalDevice::Suitable PhysicalDeviceSelector::is_device_suitable(PhysicalDevice const& pd) const +{ PhysicalDevice::Suitable suitable = PhysicalDevice::Suitable::yes; - if (criteria.name.size() > 0 && criteria.name != pd.properties.deviceName) return PhysicalDevice::Suitable::no; + if (criteria.name.size() > 0 && criteria.name != pd.properties.deviceName) + return PhysicalDevice::Suitable::no; - if (criteria.required_version > pd.properties.apiVersion) return PhysicalDevice::Suitable::no; - if (criteria.desired_version > pd.properties.apiVersion) suitable = PhysicalDevice::Suitable::partial; + if (criteria.required_version > pd.properties.apiVersion) + return PhysicalDevice::Suitable::no; + if (criteria.desired_version > pd.properties.apiVersion) + suitable = PhysicalDevice::Suitable::partial; - bool dedicated_compute = detail::get_dedicated_queue_index(pd.queue_families, VK_QUEUE_COMPUTE_BIT, VK_QUEUE_TRANSFER_BIT).has_value(); - bool dedicated_transfer = detail::get_dedicated_queue_index(pd.queue_families, VK_QUEUE_TRANSFER_BIT, VK_QUEUE_COMPUTE_BIT).has_value(); - bool separate_compute = detail::get_separate_queue_index(pd.queue_families, VK_QUEUE_COMPUTE_BIT, VK_QUEUE_TRANSFER_BIT).has_value(); - bool separate_transfer = detail::get_separate_queue_index(pd.queue_families, VK_QUEUE_TRANSFER_BIT, VK_QUEUE_COMPUTE_BIT).has_value(); + bool dedicated_compute = + detail::get_dedicated_queue_index(pd.queue_families, VK_QUEUE_COMPUTE_BIT, VK_QUEUE_TRANSFER_BIT).has_value(); + bool dedicated_transfer = + detail::get_dedicated_queue_index(pd.queue_families, VK_QUEUE_TRANSFER_BIT, VK_QUEUE_COMPUTE_BIT).has_value(); + bool separate_compute = + detail::get_separate_queue_index(pd.queue_families, VK_QUEUE_COMPUTE_BIT, VK_QUEUE_TRANSFER_BIT).has_value(); + bool separate_transfer = + detail::get_separate_queue_index(pd.queue_families, VK_QUEUE_TRANSFER_BIT, VK_QUEUE_COMPUTE_BIT).has_value(); - bool present_queue = detail::get_present_queue_index(pd.physical_device, instance_info.surface, pd.queue_families).has_value(); + bool present_queue = + detail::get_present_queue_index(pd.physical_device, instance_info.surface, pd.queue_families).has_value(); if (criteria.require_dedicated_compute_queue && !dedicated_compute) { @@ -1188,7 +1434,8 @@ PhysicalDevice::Suitable PhysicalDeviceSelector::is_device_suitable(PhysicalDevi { return PhysicalDevice::Suitable::no; } - if (criteria.require_separate_transfer_queue && !separate_transfer) { + if (criteria.require_separate_transfer_queue && !separate_transfer) + { return PhysicalDevice::Suitable::no; } if (criteria.require_present && !present_queue && !criteria.defer_surface_initialization) @@ -1201,41 +1448,54 @@ PhysicalDevice::Suitable PhysicalDeviceSelector::is_device_suitable(PhysicalDevi if (required_extensions_supported.size() != criteria.required_extensions.size()) return PhysicalDevice::Suitable::no; - auto desired_extensions_supported = detail::check_device_extension_support(pd.available_extensions, criteria.desired_extensions); + auto desired_extensions_supported = + detail::check_device_extension_support(pd.available_extensions, criteria.desired_extensions); if (desired_extensions_supported.size() != criteria.desired_extensions.size()) suitable = PhysicalDevice::Suitable::partial; - if (!criteria.defer_surface_initialization && criteria.require_present) { + if (!criteria.defer_surface_initialization && criteria.require_present) + { std::vector formats; - std::vector present_modes; - - auto formats_ret = detail::get_vector(formats, - detail::vulkan_functions().fp_vkGetPhysicalDeviceSurfaceFormatsKHR, - pd.physical_device, - instance_info.surface); - auto present_modes_ret = detail::get_vector(present_modes, - detail::vulkan_functions().fp_vkGetPhysicalDeviceSurfacePresentModesKHR, - pd.physical_device, - instance_info.surface); - - if (formats_ret != VK_SUCCESS || present_modes_ret != VK_SUCCESS || formats.empty() || present_modes.empty()) { + std::vector present_modes; + + auto formats_ret = + detail::get_vector(formats, + detail::vulkan_functions().fp_vkGetPhysicalDeviceSurfaceFormatsKHR, + pd.physical_device, + instance_info.surface); + auto present_modes_ret = detail::get_vector( + present_modes, + detail::vulkan_functions().fp_vkGetPhysicalDeviceSurfacePresentModesKHR, + pd.physical_device, + instance_info.surface); + + if (formats_ret != VK_SUCCESS || present_modes_ret != VK_SUCCESS || formats.empty() || present_modes.empty()) + { return PhysicalDevice::Suitable::no; } } - if (!criteria.allow_any_type && pd.properties.deviceType != static_cast(criteria.preferred_type)) { + if (!criteria.allow_any_type && + pd.properties.deviceType != static_cast(criteria.preferred_type)) + { suitable = PhysicalDevice::Suitable::partial; } bool required_features_supported = detail::supports_features( pd.features, criteria.required_features, pd.extended_features_chain, criteria.extended_features_chain); - if (!required_features_supported) return PhysicalDevice::Suitable::no; + if (!required_features_supported) + return PhysicalDevice::Suitable::no; - for (uint32_t i = 0; i < pd.memory_properties.memoryHeapCount; i++) { - if (pd.memory_properties.memoryHeaps[i].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) { - if (pd.memory_properties.memoryHeaps[i].size < criteria.required_mem_size) { + for (uint32_t i = 0; i < pd.memory_properties.memoryHeapCount; i++) + { + if (pd.memory_properties.memoryHeaps[i].flags & VK_MEMORY_HEAP_DEVICE_LOCAL_BIT) + { + if (pd.memory_properties.memoryHeaps[i].size < criteria.required_mem_size) + { return PhysicalDevice::Suitable::no; - } else if (pd.memory_properties.memoryHeaps[i].size < criteria.desired_mem_size) { + } + else if (pd.memory_properties.memoryHeaps[i].size < criteria.desired_mem_size) + { suitable = PhysicalDevice::Suitable::partial; } } @@ -1244,23 +1504,27 @@ PhysicalDevice::Suitable PhysicalDeviceSelector::is_device_suitable(PhysicalDevi return suitable; } // delegate construction to the one with an explicit surface parameter -PhysicalDeviceSelector::PhysicalDeviceSelector(Instance const& instance) - : PhysicalDeviceSelector(instance, VK_NULL_HANDLE) {} +PhysicalDeviceSelector::PhysicalDeviceSelector(Instance const& instance) : + PhysicalDeviceSelector(instance, VK_NULL_HANDLE) +{} -PhysicalDeviceSelector::PhysicalDeviceSelector(Instance const& instance, VkSurfaceKHR surface) { - instance_info.instance = instance.instance; - instance_info.version = instance.instance_version; +PhysicalDeviceSelector::PhysicalDeviceSelector(Instance const& instance, VkSurfaceKHR surface) +{ + instance_info.instance = instance.instance; + instance_info.version = instance.instance_version; instance_info.properties2_ext_enabled = instance.properties2_ext_enabled; - instance_info.surface = surface; - criteria.require_present = !instance.headless; - criteria.required_version = instance.api_version; - criteria.desired_version = instance.api_version; + instance_info.surface = surface; + criteria.require_present = !instance.headless; + criteria.required_version = instance.api_version; + criteria.desired_version = instance.api_version; } -std::vector PhysicalDeviceSelector::select_impl(DeviceSelectionMode selection) const { +std::vector PhysicalDeviceSelector::select_impl(DeviceSelectionMode selection) const +{ #if !defined(NDEBUG) // Validation - for (const auto& node : criteria.extended_features_chain.nodes) { + for (const auto& node : criteria.extended_features_chain.nodes) + { assert(node.sType != static_cast(0) && "Features struct sType must be filled with the struct's " "corresponding VkStructureType enum"); @@ -1270,9 +1534,10 @@ std::vector PhysicalDeviceSelector::select_impl(DeviceSelectionM } #endif - if (criteria.require_present && !criteria.defer_surface_initialization) { + if (criteria.require_present && !criteria.defer_surface_initialization) + { if (instance_info.surface == VK_NULL_HANDLE) - throw to_exception( PhysicalDeviceError::no_surface_provided); + throw to_exception(PhysicalDeviceError::no_surface_provided); } // Get the VkPhysicalDevice handles on the system @@ -1280,17 +1545,19 @@ std::vector PhysicalDeviceSelector::select_impl(DeviceSelectionM auto vk_physical_devices_ret = detail::get_vector( vk_physical_devices, detail::vulkan_functions().fp_vkEnumeratePhysicalDevices, instance_info.instance); - if (vk_physical_devices_ret != VK_SUCCESS) { + if (vk_physical_devices_ret != VK_SUCCESS) + { throw to_exception(PhysicalDeviceError::failed_enumerate_physical_devices, vk_physical_devices_ret); } - if (vk_physical_devices.size() == 0) { + if (vk_physical_devices.size() == 0) + { throw to_exception(PhysicalDeviceError::no_physical_devices_found); } auto fill_out_phys_dev_with_criteria = [&](PhysicalDevice& phys_dev) { - phys_dev.features = criteria.required_features; + phys_dev.features = criteria.required_features; phys_dev.extended_features_chain = criteria.extended_features_chain; - bool portability_ext_available = false; + bool portability_ext_available = false; for (const auto& ext : phys_dev.available_extensions) if (criteria.enable_portability_subset && ext == "VK_KHR_portability_subset") portability_ext_available = true; @@ -1299,165 +1566,207 @@ std::vector PhysicalDeviceSelector::select_impl(DeviceSelectionM detail::check_device_extension_support(phys_dev.available_extensions, criteria.desired_extensions); phys_dev.extensions_to_enable.clear(); - phys_dev.extensions_to_enable.insert( - phys_dev.extensions_to_enable.end(), criteria.required_extensions.begin(), criteria.required_extensions.end()); - phys_dev.extensions_to_enable.insert( - phys_dev.extensions_to_enable.end(), desired_extensions_supported.begin(), desired_extensions_supported.end()); - if (portability_ext_available) { + phys_dev.extensions_to_enable.insert(phys_dev.extensions_to_enable.end(), + criteria.required_extensions.begin(), + criteria.required_extensions.end()); + phys_dev.extensions_to_enable.insert(phys_dev.extensions_to_enable.end(), + desired_extensions_supported.begin(), + desired_extensions_supported.end()); + if (portability_ext_available) + { phys_dev.extensions_to_enable.push_back("VK_KHR_portability_subset"); } }; // if this option is set, always return only the first physical device found - if (criteria.use_first_gpu_unconditionally && vk_physical_devices.size() > 0) { - PhysicalDevice physical_device = populate_device_details(vk_physical_devices[0], criteria.extended_features_chain); + if (criteria.use_first_gpu_unconditionally && vk_physical_devices.size() > 0) + { + PhysicalDevice physical_device = + populate_device_details(vk_physical_devices[0], criteria.extended_features_chain); fill_out_phys_dev_with_criteria(physical_device); return std::vector{ physical_device }; } // Populate their details and check their suitability std::vector physical_devices; - for (auto& vk_physical_device : vk_physical_devices) { + for (auto& vk_physical_device : vk_physical_devices) + { PhysicalDevice phys_dev = populate_device_details(vk_physical_device, criteria.extended_features_chain); - phys_dev.suitable = is_device_suitable(phys_dev); - if (phys_dev.suitable != PhysicalDevice::Suitable::no) { + phys_dev.suitable = is_device_suitable(phys_dev); + if (phys_dev.suitable != PhysicalDevice::Suitable::no) + { physical_devices.push_back(phys_dev); } } // sort the list into fully and partially suitable devices. use stable_partition to maintain relative order - const auto partition_index = std::stable_partition(physical_devices.begin(), physical_devices.end(), [](auto const& pd) { - return pd.suitable == PhysicalDevice::Suitable::yes; - }); + const auto partition_index = + std::stable_partition(physical_devices.begin(), physical_devices.end(), [](auto const& pd) { + return pd.suitable == PhysicalDevice::Suitable::yes; + }); // Remove the partially suitable elements if they aren't desired - if (selection == DeviceSelectionMode::only_fully_suitable) { + if (selection == DeviceSelectionMode::only_fully_suitable) + { physical_devices.erase(partition_index, physical_devices.end()); } // Make the physical device ready to be used to create a Device from it - for (auto& physical_device : physical_devices) { + for (auto& physical_device : physical_devices) + { fill_out_phys_dev_with_criteria(physical_device); } return physical_devices; } -PhysicalDevice PhysicalDeviceSelector::select(DeviceSelectionMode selection) const { +PhysicalDevice PhysicalDeviceSelector::select(DeviceSelectionMode selection) const +{ auto const selected_devices = select_impl(selection); - if (selected_devices.size() == 0) { + if (selected_devices.size() == 0) + { throw to_exception(PhysicalDeviceError::no_suitable_device); } return selected_devices.at(0); } -// Return all devices which are considered suitable - intended for applications which want to let the user pick the physical device -std::vector PhysicalDeviceSelector::select_devices(DeviceSelectionMode selection) const { +// Return all devices which are considered suitable - intended for applications which want to let the user pick the +// physical device +std::vector PhysicalDeviceSelector::select_devices(DeviceSelectionMode selection) const +{ auto const selected_devices = select_impl(selection); - if (selected_devices.size() == 0) { + if (selected_devices.size() == 0) + { throw to_exception(PhysicalDeviceError::no_suitable_device); } return selected_devices; } -std::vector PhysicalDeviceSelector::select_device_names(DeviceSelectionMode selection) const { +std::vector PhysicalDeviceSelector::select_device_names(DeviceSelectionMode selection) const +{ auto const selected_devices = select_impl(selection); - if (selected_devices.size() == 0) { + if (selected_devices.size() == 0) + { throw to_exception(PhysicalDeviceError::no_suitable_device); } std::vector names; - for (const auto& pd : selected_devices) { + for (const auto& pd : selected_devices) + { names.push_back(pd.name); } return names; } -PhysicalDeviceSelector& PhysicalDeviceSelector::set_surface(VkSurfaceKHR surface) { +PhysicalDeviceSelector& PhysicalDeviceSelector::set_surface(VkSurfaceKHR surface) +{ instance_info.surface = surface; return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::set_name(std::string const& name) { +PhysicalDeviceSelector& PhysicalDeviceSelector::set_name(std::string const& name) +{ criteria.name = name; return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::prefer_gpu_device_type(PreferredDeviceType type) { +PhysicalDeviceSelector& PhysicalDeviceSelector::prefer_gpu_device_type(PreferredDeviceType type) +{ criteria.preferred_type = type; return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::allow_any_gpu_device_type(bool allow_any_type) { +PhysicalDeviceSelector& PhysicalDeviceSelector::allow_any_gpu_device_type(bool allow_any_type) +{ criteria.allow_any_type = allow_any_type; return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::require_present(bool require) { +PhysicalDeviceSelector& PhysicalDeviceSelector::require_present(bool require) +{ criteria.require_present = require; return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::require_dedicated_transfer_queue() { +PhysicalDeviceSelector& PhysicalDeviceSelector::require_dedicated_transfer_queue() +{ criteria.require_dedicated_transfer_queue = true; return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::require_dedicated_compute_queue() { +PhysicalDeviceSelector& PhysicalDeviceSelector::require_dedicated_compute_queue() +{ criteria.require_dedicated_compute_queue = true; return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::require_separate_transfer_queue() { +PhysicalDeviceSelector& PhysicalDeviceSelector::require_separate_transfer_queue() +{ criteria.require_separate_transfer_queue = true; return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::require_separate_compute_queue() { +PhysicalDeviceSelector& PhysicalDeviceSelector::require_separate_compute_queue() +{ criteria.require_separate_compute_queue = true; return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::required_device_memory_size(VkDeviceSize size) { +PhysicalDeviceSelector& PhysicalDeviceSelector::required_device_memory_size(VkDeviceSize size) +{ criteria.required_mem_size = size; return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::desired_device_memory_size(VkDeviceSize size) { +PhysicalDeviceSelector& PhysicalDeviceSelector::desired_device_memory_size(VkDeviceSize size) +{ criteria.desired_mem_size = size; return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::add_required_extension(const char* extension) { +PhysicalDeviceSelector& PhysicalDeviceSelector::add_required_extension(const char* extension) +{ criteria.required_extensions.push_back(extension); return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::add_required_extensions(std::vector const& extensions) { - for (const auto& ext : extensions) { +PhysicalDeviceSelector& PhysicalDeviceSelector::add_required_extensions(std::vector const& extensions) +{ + for (const auto& ext : extensions) + { criteria.required_extensions.push_back(ext); } return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::add_required_extensions(size_t count, const char* const* extensions) { - if (!extensions || count == 0) return *this; - for (size_t i = 0; i < count; i++) { +PhysicalDeviceSelector& PhysicalDeviceSelector::add_required_extensions(size_t count, const char* const* extensions) +{ + if (!extensions || count == 0) + return *this; + for (size_t i = 0; i < count; i++) + { criteria.required_extensions.push_back(extensions[i]); } return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::add_desired_extension(const char* extension) { +PhysicalDeviceSelector& PhysicalDeviceSelector::add_desired_extension(const char* extension) +{ criteria.desired_extensions.push_back(extension); return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::add_desired_extensions(const std::vector& extensions) { - for (const auto& ext : extensions) { +PhysicalDeviceSelector& PhysicalDeviceSelector::add_desired_extensions(const std::vector& extensions) +{ + for (const auto& ext : extensions) + { criteria.desired_extensions.push_back(ext); } return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::set_minimum_version(uint32_t major, uint32_t minor) { +PhysicalDeviceSelector& PhysicalDeviceSelector::set_minimum_version(uint32_t major, uint32_t minor) +{ criteria.required_version = VKB_MAKE_VK_VERSION(0, major, minor, 0); return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::set_desired_version(uint32_t major, uint32_t minor) { +PhysicalDeviceSelector& PhysicalDeviceSelector::set_desired_version(uint32_t major, uint32_t minor) +{ criteria.desired_version = VKB_MAKE_VK_VERSION(0, major, minor, 0); return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::disable_portability_subset() { +PhysicalDeviceSelector& PhysicalDeviceSelector::disable_portability_subset() +{ criteria.enable_portability_subset = false; return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::set_required_features(VkPhysicalDeviceFeatures const& features) { +PhysicalDeviceSelector& PhysicalDeviceSelector::set_required_features(VkPhysicalDeviceFeatures const& features) +{ detail::combine_features(criteria.required_features, features); return *this; } @@ -1465,98 +1774,129 @@ PhysicalDeviceSelector& PhysicalDeviceSelector::set_required_features(VkPhysical // The implementation of the set_required_features_1X functions sets the sType manually. This was a poor choice since // users of Vulkan should expect to fill out their structs properly. To make the functions take the struct parameter by // const reference, a local copy must be made in order to set the sType. -PhysicalDeviceSelector& PhysicalDeviceSelector::set_required_features_11(VkPhysicalDeviceVulkan11Features const& features_11) { +PhysicalDeviceSelector& +PhysicalDeviceSelector::set_required_features_11(VkPhysicalDeviceVulkan11Features const& features_11) +{ VkPhysicalDeviceVulkan11Features features_11_copy = features_11; - features_11_copy.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; + features_11_copy.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES; add_required_extension_features(features_11_copy); return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::set_required_features_12(VkPhysicalDeviceVulkan12Features const& features_12) { +PhysicalDeviceSelector& +PhysicalDeviceSelector::set_required_features_12(VkPhysicalDeviceVulkan12Features const& features_12) +{ VkPhysicalDeviceVulkan12Features features_12_copy = features_12; - features_12_copy.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; + features_12_copy.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES; add_required_extension_features(features_12_copy); return *this; } #endif #if defined(VKB_VK_API_VERSION_1_3) -PhysicalDeviceSelector& PhysicalDeviceSelector::set_required_features_13(VkPhysicalDeviceVulkan13Features const& features_13) { +PhysicalDeviceSelector& +PhysicalDeviceSelector::set_required_features_13(VkPhysicalDeviceVulkan13Features const& features_13) +{ VkPhysicalDeviceVulkan13Features features_13_copy = features_13; - features_13_copy.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; + features_13_copy.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES; add_required_extension_features(features_13_copy); return *this; } #endif -PhysicalDeviceSelector& PhysicalDeviceSelector::defer_surface_initialization() { +PhysicalDeviceSelector& PhysicalDeviceSelector::defer_surface_initialization() +{ criteria.defer_surface_initialization = true; return *this; } -PhysicalDeviceSelector& PhysicalDeviceSelector::select_first_device_unconditionally(bool unconditionally) { +PhysicalDeviceSelector& PhysicalDeviceSelector::select_first_device_unconditionally(bool unconditionally) +{ criteria.use_first_gpu_unconditionally = unconditionally; return *this; } // PhysicalDevice -bool PhysicalDevice::has_dedicated_compute_queue() const { +bool PhysicalDevice::has_dedicated_compute_queue() const +{ return detail::get_dedicated_queue_index(queue_families, VK_QUEUE_COMPUTE_BIT, VK_QUEUE_TRANSFER_BIT).has_value(); } -bool PhysicalDevice::has_separate_compute_queue() const { +bool PhysicalDevice::has_separate_compute_queue() const +{ return detail::get_separate_queue_index(queue_families, VK_QUEUE_COMPUTE_BIT, VK_QUEUE_TRANSFER_BIT).has_value(); } -bool PhysicalDevice::has_dedicated_transfer_queue() const { +bool PhysicalDevice::has_dedicated_transfer_queue() const +{ return detail::get_dedicated_queue_index(queue_families, VK_QUEUE_TRANSFER_BIT, VK_QUEUE_COMPUTE_BIT).has_value(); } -bool PhysicalDevice::has_separate_transfer_queue() const { +bool PhysicalDevice::has_separate_transfer_queue() const +{ return detail::get_separate_queue_index(queue_families, VK_QUEUE_TRANSFER_BIT, VK_QUEUE_COMPUTE_BIT).has_value(); } -std::vector PhysicalDevice::get_queue_families() const { return queue_families; } -std::vector PhysicalDevice::get_extensions() const { return extensions_to_enable; } -std::vector PhysicalDevice::get_available_extensions() const { return available_extensions; } -bool PhysicalDevice::is_extension_present(const char* ext) const { - return std::find_if(std::begin(available_extensions), std::end(available_extensions), [ext](std::string const& ext_name) { - return ext_name == ext; - }) != std::end(available_extensions); +std::vector PhysicalDevice::get_queue_families() const +{ + return queue_families; +} +std::vector PhysicalDevice::get_extensions() const +{ + return extensions_to_enable; +} +std::vector PhysicalDevice::get_available_extensions() const +{ + return available_extensions; } -bool PhysicalDevice::enable_extension_if_present(const char* extension) { +bool PhysicalDevice::is_extension_present(const char* ext) const +{ + return std::find_if(std::begin(available_extensions), + std::end(available_extensions), + [ext](std::string const& ext_name) { return ext_name == ext; }) != + std::end(available_extensions); +} +bool PhysicalDevice::enable_extension_if_present(const char* extension) +{ auto it = std::find_if(std::begin(available_extensions), std::end(available_extensions), [extension](std::string const& ext_name) { return ext_name == extension; }); - if (it != std::end(available_extensions)) { + if (it != std::end(available_extensions)) + { extensions_to_enable.push_back(extension); return true; } return false; } -bool PhysicalDevice::enable_extensions_if_present(const std::vector& extensions) { - for (const auto extension : extensions) { +bool PhysicalDevice::enable_extensions_if_present(const std::vector& extensions) +{ + for (const auto extension : extensions) + { auto it = std::find_if(std::begin(available_extensions), std::end(available_extensions), [extension](std::string const& ext_name) { return ext_name == extension; }); - if (it == std::end(available_extensions)) return false; + if (it == std::end(available_extensions)) + return false; } - for (const auto extension : extensions) - extensions_to_enable.push_back(extension); + for (const auto extension : extensions) extensions_to_enable.push_back(extension); return true; } -bool PhysicalDevice::enable_features_if_present(const VkPhysicalDeviceFeatures& features_to_enable) { +bool PhysicalDevice::enable_features_if_present(const VkPhysicalDeviceFeatures& features_to_enable) +{ VkPhysicalDeviceFeatures actual_pdf{}; detail::vulkan_functions().fp_vkGetPhysicalDeviceFeatures(physical_device, &actual_pdf); bool required_features_supported = detail::supports_features(actual_pdf, features_to_enable, {}, {}); - if (required_features_supported) { + if (required_features_supported) + { detail::combine_features(features, features_to_enable); } return required_features_supported; } -bool PhysicalDevice::is_features_node_present(detail::GenericFeaturesPNextNode const& node) const { +bool PhysicalDevice::is_features_node_present(detail::GenericFeaturesPNextNode const& node) const +{ detail::GenericFeatureChain requested_features; requested_features.nodes.push_back(node); return extended_features_chain.find_and_match(requested_features); } -bool PhysicalDevice::enable_features_node_if_present(detail::GenericFeaturesPNextNode const& node) { +bool PhysicalDevice::enable_features_node_if_present(detail::GenericFeaturesPNextNode const& node) +{ VkPhysicalDeviceFeatures2 actual_pdf2{}; detail::GenericFeatureChain requested_features; @@ -1564,34 +1904,45 @@ bool PhysicalDevice::enable_features_node_if_present(detail::GenericFeaturesPNex detail::GenericFeatureChain fill_chain = requested_features; // Zero out supported features - memset(fill_chain.nodes.front().fields, UINT8_MAX, sizeof(VkBool32) * detail::GenericFeaturesPNextNode::field_capacity); + memset(fill_chain.nodes.front().fields, + UINT8_MAX, + sizeof(VkBool32) * detail::GenericFeaturesPNextNode::field_capacity); actual_pdf2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; fill_chain.chain_up(actual_pdf2); bool required_features_supported = false; - bool instance_is_1_1 = instance_version >= VKB_VK_API_VERSION_1_1; - if (instance_is_1_1 || properties2_ext_enabled) { - if (instance_is_1_1) { + bool instance_is_1_1 = instance_version >= VKB_VK_API_VERSION_1_1; + if (instance_is_1_1 || properties2_ext_enabled) + { + if (instance_is_1_1) + { detail::vulkan_functions().fp_vkGetPhysicalDeviceFeatures2(physical_device, &actual_pdf2); - } else { + } + else + { detail::vulkan_functions().fp_vkGetPhysicalDeviceFeatures2KHR(physical_device, &actual_pdf2); } required_features_supported = fill_chain.match_all(requested_features); - if (required_features_supported) { + if (required_features_supported) + { extended_features_chain.combine(requested_features); } } return required_features_supported; } - -PhysicalDevice::operator VkPhysicalDevice() const { return this->physical_device; } +PhysicalDevice::operator VkPhysicalDevice() const +{ + return this->physical_device; +} // ---- Queues ---- // -std::optional Device::get_queue_index(QueueType type) const { - switch (type) { +std::optional Device::get_queue_index(QueueType type) const +{ + switch (type) + { case QueueType::present: return detail::get_present_queue_index(physical_device.physical_device, surface, queue_families); break; @@ -1606,8 +1957,10 @@ std::optional Device::get_queue_index(QueueType type) const { } } -std::optional Device::get_dedicated_queue_index(QueueType type) const { - switch (type) { +std::optional Device::get_dedicated_queue_index(QueueType type) const +{ + switch (type) + { case QueueType::compute: return detail::get_dedicated_queue_index(queue_families, VK_QUEUE_COMPUTE_BIT, VK_QUEUE_TRANSFER_BIT); case QueueType::transfer: @@ -1617,17 +1970,21 @@ std::optional Device::get_dedicated_queue_index(QueueType type) const } } -std::optional Device::get_queue(QueueType type) const { +std::optional Device::get_queue(QueueType type) const +{ auto index = get_queue_index(type); - if (!index.has_value()) return {}; + if (!index.has_value()) + return {}; VkQueue out_queue; internal_table.fp_vkGetDeviceQueue(device, *index, 0, &out_queue); return out_queue; } -std::optional Device::get_dedicated_queue(QueueType type) const { +std::optional Device::get_dedicated_queue(QueueType type) const +{ auto index = get_dedicated_queue_index(type); - if (!index.has_value()) return {}; + if (!index.has_value()) + return {}; VkQueue out_queue; internal_table.fp_vkGetDeviceQueue(device, *index, 0, &out_queue); return out_queue; @@ -1635,123 +1992,156 @@ std::optional Device::get_dedicated_queue(QueueType type) const { // ---- Dispatch ---- // -vkb::DispatchTable Device::make_table() const { return { device, fp_vkGetDeviceProcAddr }; } +vkb::DispatchTable Device::make_table() const +{ + return { device, fp_vkGetDeviceProcAddr }; +} // ---- Device ---- // -Device::operator VkDevice() const { return this->device; } +Device::operator VkDevice() const +{ + return this->device; +} -CustomQueueDescription::CustomQueueDescription(uint32_t index, std::vector priorities) - : index(index), priorities(std::move(priorities)) {} +CustomQueueDescription::CustomQueueDescription(uint32_t index, std::vector priorities) : + index(index), priorities(std::move(priorities)) +{} -void destroy_device(Device const& device) { +void destroy_device(Device const& device) +{ device.internal_table.fp_vkDestroyDevice(device.device, device.allocation_callbacks); } -DeviceBuilder::DeviceBuilder(PhysicalDevice phys_device) { physical_device = std::move(phys_device); } +DeviceBuilder::DeviceBuilder(PhysicalDevice phys_device) +{ + physical_device = std::move(phys_device); +} -Device DeviceBuilder::build() const { +Device DeviceBuilder::build() const +{ std::vector queue_descriptions; queue_descriptions.insert(queue_descriptions.end(), info.queue_descriptions.begin(), info.queue_descriptions.end()); - if (queue_descriptions.empty()) { - for (uint32_t i = 0; i < physical_device.queue_families.size(); i++) { + if (queue_descriptions.empty()) + { + for (uint32_t i = 0; i < physical_device.queue_families.size(); i++) + { queue_descriptions.emplace_back(i, std::vector{ 1.0f }); } } std::vector queueCreateInfos; - for (auto& desc : queue_descriptions) { + for (auto& desc : queue_descriptions) + { VkDeviceQueueCreateInfo queue_create_info = {}; - queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; - queue_create_info.queueFamilyIndex = desc.index; - queue_create_info.queueCount = static_cast(desc.priorities.size()); - queue_create_info.pQueuePriorities = desc.priorities.data(); + queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO; + queue_create_info.queueFamilyIndex = desc.index; + queue_create_info.queueCount = static_cast(desc.priorities.size()); + queue_create_info.pQueuePriorities = desc.priorities.data(); queueCreateInfos.push_back(queue_create_info); } std::vector extensions_to_enable; - for (const auto& ext : physical_device.extensions_to_enable) { + for (const auto& ext : physical_device.extensions_to_enable) + { extensions_to_enable.push_back(ext.c_str()); } if (physical_device.surface != VK_NULL_HANDLE || physical_device.defer_surface_initialization) extensions_to_enable.push_back({ VK_KHR_SWAPCHAIN_EXTENSION_NAME }); std::vector final_pnext_chain; - VkDeviceCreateInfo device_create_info = {}; + VkDeviceCreateInfo device_create_info = {}; bool user_defined_phys_dev_features_2 = false; - for (auto& pnext : info.pNext_chain) { - if (pnext->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2) { + for (auto& pnext : info.pNext_chain) + { + if (pnext->sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2) + { user_defined_phys_dev_features_2 = true; break; } } - if (user_defined_phys_dev_features_2 && !physical_device.extended_features_chain.nodes.empty()) { - throw to_exception(DeviceError::VkPhysicalDeviceFeatures2_in_pNext_chain_while_using_add_required_extension_features); + if (user_defined_phys_dev_features_2 && !physical_device.extended_features_chain.nodes.empty()) + { + throw to_exception( + DeviceError::VkPhysicalDeviceFeatures2_in_pNext_chain_while_using_add_required_extension_features); } // These objects must be alive during the call to vkCreateDevice - auto physical_device_extension_features_copy = physical_device.extended_features_chain; + auto physical_device_extension_features_copy = physical_device.extended_features_chain; VkPhysicalDeviceFeatures2 local_features2{}; - local_features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; + local_features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2; local_features2.features = physical_device.features; - if (!user_defined_phys_dev_features_2) { - if (physical_device.instance_version >= VKB_VK_API_VERSION_1_1 || physical_device.properties2_ext_enabled) { + if (!user_defined_phys_dev_features_2) + { + if (physical_device.instance_version >= VKB_VK_API_VERSION_1_1 || physical_device.properties2_ext_enabled) + { final_pnext_chain.push_back(reinterpret_cast(&local_features2)); - for (auto& features_node : physical_device_extension_features_copy.nodes) { + for (auto& features_node : physical_device_extension_features_copy.nodes) + { final_pnext_chain.push_back(reinterpret_cast(&features_node)); } - } else { - // Only set device_create_info.pEnabledFeatures when the pNext chain does not contain a VkPhysicalDeviceFeatures2 structure + } + else + { + // Only set device_create_info.pEnabledFeatures when the pNext chain does not contain a + // VkPhysicalDeviceFeatures2 structure device_create_info.pEnabledFeatures = &physical_device.features; } } - for (auto& pnext : info.pNext_chain) { + for (auto& pnext : info.pNext_chain) + { final_pnext_chain.push_back(pnext); } detail::setup_pNext_chain(device_create_info, final_pnext_chain); #if !defined(NDEBUG) - for (auto& node : final_pnext_chain) { + for (auto& node : final_pnext_chain) + { assert(node->sType != VK_STRUCTURE_TYPE_APPLICATION_INFO); } #endif - device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; - device_create_info.flags = info.flags; - device_create_info.queueCreateInfoCount = static_cast(queueCreateInfos.size()); - device_create_info.pQueueCreateInfos = queueCreateInfos.data(); - device_create_info.enabledExtensionCount = static_cast(extensions_to_enable.size()); + device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; + device_create_info.flags = info.flags; + device_create_info.queueCreateInfoCount = static_cast(queueCreateInfos.size()); + device_create_info.pQueueCreateInfos = queueCreateInfos.data(); + device_create_info.enabledExtensionCount = static_cast(extensions_to_enable.size()); device_create_info.ppEnabledExtensionNames = extensions_to_enable.data(); Device device; VkResult res = detail::vulkan_functions().fp_vkCreateDevice( physical_device.physical_device, &device_create_info, info.allocation_callbacks, &device.device); - if (res != VK_SUCCESS) { + if (res != VK_SUCCESS) + { throw to_exception(DeviceError::failed_create_device, res); } - device.physical_device = physical_device; - device.surface = physical_device.surface; - device.queue_families = physical_device.queue_families; - device.allocation_callbacks = info.allocation_callbacks; + device.physical_device = physical_device; + device.surface = physical_device.surface; + device.queue_families = physical_device.queue_families; + device.allocation_callbacks = info.allocation_callbacks; device.fp_vkGetDeviceProcAddr = detail::vulkan_functions().fp_vkGetDeviceProcAddr; - detail::vulkan_functions().get_device_proc_addr(device.device, device.internal_table.fp_vkGetDeviceQueue, "vkGetDeviceQueue"); - detail::vulkan_functions().get_device_proc_addr(device.device, device.internal_table.fp_vkDestroyDevice, "vkDestroyDevice"); + detail::vulkan_functions().get_device_proc_addr( + device.device, device.internal_table.fp_vkGetDeviceQueue, "vkGetDeviceQueue"); + detail::vulkan_functions().get_device_proc_addr( + device.device, device.internal_table.fp_vkDestroyDevice, "vkDestroyDevice"); device.instance_version = physical_device.instance_version; return device; } -DeviceBuilder& DeviceBuilder::custom_queue_setup(std::vector queue_descriptions) { +DeviceBuilder& DeviceBuilder::custom_queue_setup(std::vector queue_descriptions) +{ info.queue_descriptions = std::move(queue_descriptions); return *this; } -DeviceBuilder& DeviceBuilder::set_allocation_callbacks(VkAllocationCallbacks* callbacks) { +DeviceBuilder& DeviceBuilder::set_allocation_callbacks(VkAllocationCallbacks* callbacks) +{ info.allocation_callbacks = callbacks; return *this; } @@ -1760,13 +2150,15 @@ DeviceBuilder& DeviceBuilder::set_allocation_callbacks(VkAllocationCallbacks* ca GFXRECON_BEGIN_NAMESPACE(detail) -struct SurfaceSupportDetails { - VkSurfaceCapabilitiesKHR capabilities; +struct SurfaceSupportDetails +{ + VkSurfaceCapabilitiesKHR capabilities; std::vector formats; - std::vector present_modes; + std::vector present_modes; }; -enum class SurfaceSupportError { +enum class SurfaceSupportError +{ surface_handle_null, failed_get_surface_capabilities, failed_enumerate_surface_formats, @@ -1788,10 +2180,12 @@ const char* to_string(SurfaceSupportError err) } } -std::exception to_exception(SurfaceSupportError error) { +std::exception to_exception(SurfaceSupportError error) +{ return std::runtime_error(to_string(error)); } -std::exception to_exception(SurfaceSupportError error, VkResult result) { +std::exception to_exception(SurfaceSupportError error, VkResult result) +{ std::string message{}; message.append(to_string(error)); message.append(": "); @@ -1799,17 +2193,21 @@ std::exception to_exception(SurfaceSupportError error, VkResult result) { return std::runtime_error(message); } -SurfaceSupportDetails query_surface_support_details(VkPhysicalDevice phys_device, VkSurfaceKHR surface) { - if (surface == VK_NULL_HANDLE) throw to_exception(SurfaceSupportError::surface_handle_null); +SurfaceSupportDetails query_surface_support_details(VkPhysicalDevice phys_device, VkSurfaceKHR surface) +{ + if (surface == VK_NULL_HANDLE) + throw to_exception(SurfaceSupportError::surface_handle_null); VkSurfaceCapabilitiesKHR capabilities; - VkResult res = detail::vulkan_functions().fp_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(phys_device, surface, &capabilities); - if (res != VK_SUCCESS) { + VkResult res = + detail::vulkan_functions().fp_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(phys_device, surface, &capabilities); + if (res != VK_SUCCESS) + { throw to_exception(SurfaceSupportError::failed_get_surface_capabilities, res); } std::vector formats; - std::vector present_modes; + std::vector present_modes; auto formats_ret = detail::get_vector( formats, detail::vulkan_functions().fp_vkGetPhysicalDeviceSurfaceFormatsKHR, phys_device, surface); @@ -1823,12 +2221,17 @@ SurfaceSupportDetails query_surface_support_details(VkPhysicalDevice phys_device return SurfaceSupportDetails{ capabilities, formats, present_modes }; } -std::optional find_desired_surface_format( - std::vector const& available_formats, std::vector const& desired_formats) { - for (auto const& desired_format : desired_formats) { - for (auto const& available_format : available_formats) { +std::optional find_desired_surface_format(std::vector const& available_formats, + std::vector const& desired_formats) +{ + for (auto const& desired_format : desired_formats) + { + for (auto const& available_format : available_formats) + { // finds the first format that is desired and available - if (desired_format.format == available_format.format && desired_format.colorSpace == available_format.colorSpace) { + if (desired_format.format == available_format.format && + desired_format.colorSpace == available_format.colorSpace) + { return desired_format; } } @@ -1837,37 +2240,54 @@ std::optional find_desired_surface_format( return {}; } -VkSurfaceFormatKHR find_best_surface_format( - std::vector const& available_formats, std::vector const& desired_formats) { +VkSurfaceFormatKHR find_best_surface_format(std::vector const& available_formats, + std::vector const& desired_formats) +{ auto surface_format_ret = detail::find_desired_surface_format(available_formats, desired_formats); return surface_format_ret.value_or(available_formats[0]); } VkPresentModeKHR find_present_mode(std::vector const& available_resent_modes, - std::vector const& desired_present_modes) { - for (auto const& desired_pm : desired_present_modes) { - for (auto const& available_pm : available_resent_modes) { + std::vector const& desired_present_modes) +{ + for (auto const& desired_pm : desired_present_modes) + { + for (auto const& available_pm : available_resent_modes) + { // finds the first present mode that is desired and available - if (desired_pm == available_pm) return desired_pm; + if (desired_pm == available_pm) + return desired_pm; } } // only present mode required, use as a fallback return VK_PRESENT_MODE_FIFO_KHR; } -template T minimum(T a, T b) { return a < b ? a : b; } -template T maximum(T a, T b) { return a > b ? a : b; } +template +T minimum(T a, T b) +{ + return a < b ? a : b; +} +template +T maximum(T a, T b) +{ + return a > b ? a : b; +} -VkExtent2D find_extent(VkSurfaceCapabilitiesKHR const& capabilities, uint32_t desired_width, uint32_t desired_height) { - if (capabilities.currentExtent.width != UINT32_MAX) { +VkExtent2D find_extent(VkSurfaceCapabilitiesKHR const& capabilities, uint32_t desired_width, uint32_t desired_height) +{ + if (capabilities.currentExtent.width != UINT32_MAX) + { return capabilities.currentExtent; - } else { + } + else + { VkExtent2D actualExtent = { desired_width, desired_height }; actualExtent.width = maximum(capabilities.minImageExtent.width, minimum(capabilities.maxImageExtent.width, actualExtent.width)); - actualExtent.height = - maximum(capabilities.minImageExtent.height, minimum(capabilities.maxImageExtent.height, actualExtent.height)); + actualExtent.height = maximum(capabilities.minImageExtent.height, + minimum(capabilities.maxImageExtent.height, actualExtent.height)); return actualExtent; } @@ -1875,50 +2295,57 @@ VkExtent2D find_extent(VkSurfaceCapabilitiesKHR const& capabilities, uint32_t de GFXRECON_END_NAMESPACE(detail) -void destroy_swapchain(Swapchain const& swapchain) { - if (swapchain.device != VK_NULL_HANDLE && swapchain.swapchain != VK_NULL_HANDLE) { - swapchain.internal_table.fp_vkDestroySwapchainKHR(swapchain.device, swapchain.swapchain, swapchain.allocation_callbacks); +void destroy_swapchain(Swapchain const& swapchain) +{ + if (swapchain.device != VK_NULL_HANDLE && swapchain.swapchain != VK_NULL_HANDLE) + { + swapchain.internal_table.fp_vkDestroySwapchainKHR( + swapchain.device, swapchain.swapchain, swapchain.allocation_callbacks); } } -SwapchainBuilder::SwapchainBuilder(Device const& device) { - info.physical_device = device.physical_device.physical_device; - info.device = device.device; - info.surface = device.surface; +SwapchainBuilder::SwapchainBuilder(Device const& device) +{ + info.physical_device = device.physical_device.physical_device; + info.device = device.device; + info.surface = device.surface; info.instance_version = device.instance_version; - auto present = device.get_queue_index(QueueType::present); - auto graphics = device.get_queue_index(QueueType::graphics); + auto present = device.get_queue_index(QueueType::present); + auto graphics = device.get_queue_index(QueueType::graphics); assert(graphics.has_value() && present.has_value() && "Graphics and Present queue indexes must be valid"); info.graphics_queue_index = *present; - info.present_queue_index = *graphics; + info.present_queue_index = *graphics; info.allocation_callbacks = device.allocation_callbacks; } -SwapchainBuilder::SwapchainBuilder(Device const& device, VkSurfaceKHR const surface) { - info.physical_device = device.physical_device.physical_device; - info.device = device.device; - info.surface = surface; +SwapchainBuilder::SwapchainBuilder(Device const& device, VkSurfaceKHR const surface) +{ + info.physical_device = device.physical_device.physical_device; + info.device = device.device; + info.surface = surface; info.instance_version = device.instance_version; - Device temp_device = device; - temp_device.surface = surface; - auto present = temp_device.get_queue_index(QueueType::present); - auto graphics = temp_device.get_queue_index(QueueType::graphics); + Device temp_device = device; + temp_device.surface = surface; + auto present = temp_device.get_queue_index(QueueType::present); + auto graphics = temp_device.get_queue_index(QueueType::graphics); assert(graphics.has_value() && present.has_value() && "Graphics and Present queue indexes must be valid"); info.graphics_queue_index = *graphics; - info.present_queue_index = *present; + info.present_queue_index = *present; info.allocation_callbacks = device.allocation_callbacks; } -SwapchainBuilder::SwapchainBuilder(VkPhysicalDevice const physical_device, - VkDevice const device, - VkSurfaceKHR const surface, +SwapchainBuilder::SwapchainBuilder(VkPhysicalDevice const physical_device, + VkDevice const device, + VkSurfaceKHR const surface, std::optional graphics_queue_index, - std::optional present_queue_index) { - info.physical_device = physical_device; - info.device = device; - info.surface = surface; + std::optional present_queue_index) +{ + info.physical_device = physical_device; + info.device = device; + info.surface = surface; info.graphics_queue_index = graphics_queue_index; - info.present_queue_index = present_queue_index; - if (!graphics_queue_index.has_value() || !present_queue_index.has_value()) { + info.present_queue_index = present_queue_index; + if (!graphics_queue_index.has_value() || !present_queue_index.has_value()) + { auto queue_families = detail::get_vector_noerror( detail::vulkan_functions().fp_vkGetPhysicalDeviceQueueFamilyProperties, physical_device); if (!graphics_queue_index.has_value()) @@ -1927,33 +2354,44 @@ SwapchainBuilder::SwapchainBuilder(VkPhysicalDevice const physical_device, info.present_queue_index = detail::get_present_queue_index(physical_device, surface, queue_families); } } -Swapchain SwapchainBuilder::build() const { - if (info.surface == VK_NULL_HANDLE) { +Swapchain SwapchainBuilder::build() const +{ + if (info.surface == VK_NULL_HANDLE) + { throw to_exception(SwapchainError::surface_handle_not_provided); } auto desired_formats = info.desired_formats; - if (desired_formats.size() == 0) add_desired_formats(desired_formats); + if (desired_formats.size() == 0) + add_desired_formats(desired_formats); auto desired_present_modes = info.desired_present_modes; - if (desired_present_modes.size() == 0) add_desired_present_modes(desired_present_modes); + if (desired_present_modes.size() == 0) + add_desired_present_modes(desired_present_modes); auto surface_support = detail::query_surface_support_details(info.physical_device, info.surface); uint32_t image_count = info.min_image_count; - if (info.required_min_image_count >= 1) { + if (info.required_min_image_count >= 1) + { if (info.required_min_image_count < surface_support.capabilities.minImageCount) throw to_exception(SwapchainError::required_min_image_count_too_low); image_count = info.required_min_image_count; - } else if (info.min_image_count == 0) { - // We intentionally use minImageCount + 1 to maintain existing behavior, even if it typically results in triple buffering on most systems. + } + else if (info.min_image_count == 0) + { + // We intentionally use minImageCount + 1 to maintain existing behavior, even if it typically results in triple + // buffering on most systems. image_count = surface_support.capabilities.minImageCount + 1; - } else { + } + else + { image_count = info.min_image_count; if (image_count < surface_support.capabilities.minImageCount) image_count = surface_support.capabilities.minImageCount; } - if (surface_support.capabilities.maxImageCount > 0 && image_count > surface_support.capabilities.maxImageCount) { + if (surface_support.capabilities.maxImageCount > 0 && image_count > surface_support.capabilities.maxImageCount) + { image_count = surface_support.capabilities.maxImageCount; } @@ -1964,20 +2402,23 @@ Swapchain SwapchainBuilder::build() const { uint32_t image_array_layers = info.array_layer_count; if (surface_support.capabilities.maxImageArrayLayers < info.array_layer_count) image_array_layers = surface_support.capabilities.maxImageArrayLayers; - if (info.array_layer_count == 0) image_array_layers = 1; + if (info.array_layer_count == 0) + image_array_layers = 1; uint32_t queue_family_indices[] = { *info.graphics_queue_index, *info.present_queue_index }; VkPresentModeKHR present_mode = detail::find_present_mode(surface_support.present_modes, desired_present_modes); - // VkSurfaceCapabilitiesKHR::supportedUsageFlags is only only valid for some present modes. For shared present modes, we should also check VkSharedPresentSurfaceCapabilitiesKHR::sharedPresentSupportedUsageFlags. + // VkSurfaceCapabilitiesKHR::supportedUsageFlags is only only valid for some present modes. For shared present + // modes, we should also check VkSharedPresentSurfaceCapabilitiesKHR::sharedPresentSupportedUsageFlags. auto is_unextended_present_mode = [](VkPresentModeKHR present_mode) { return (present_mode == VK_PRESENT_MODE_IMMEDIATE_KHR) || (present_mode == VK_PRESENT_MODE_MAILBOX_KHR) || (present_mode == VK_PRESENT_MODE_FIFO_KHR) || (present_mode == VK_PRESENT_MODE_FIFO_RELAXED_KHR); }; if (is_unextended_present_mode(present_mode) && - (info.image_usage_flags & surface_support.capabilities.supportedUsageFlags) != info.image_usage_flags) { + (info.image_usage_flags & surface_support.capabilities.supportedUsageFlags) != info.image_usage_flags) + { throw to_exception(SwapchainError::required_usage_not_supported); } @@ -1986,79 +2427,95 @@ Swapchain SwapchainBuilder::build() const { pre_transform = surface_support.capabilities.currentTransform; VkSwapchainCreateInfoKHR swapchain_create_info = {}; - swapchain_create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; + swapchain_create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; detail::setup_pNext_chain(swapchain_create_info, info.pNext_chain); #if !defined(NDEBUG) - for (auto& node : info.pNext_chain) { + for (auto& node : info.pNext_chain) + { assert(node->sType != VK_STRUCTURE_TYPE_APPLICATION_INFO); } #endif - swapchain_create_info.flags = info.create_flags; - swapchain_create_info.surface = info.surface; - swapchain_create_info.minImageCount = image_count; - swapchain_create_info.imageFormat = surface_format.format; - swapchain_create_info.imageColorSpace = surface_format.colorSpace; - swapchain_create_info.imageExtent = extent; + swapchain_create_info.flags = info.create_flags; + swapchain_create_info.surface = info.surface; + swapchain_create_info.minImageCount = image_count; + swapchain_create_info.imageFormat = surface_format.format; + swapchain_create_info.imageColorSpace = surface_format.colorSpace; + swapchain_create_info.imageExtent = extent; swapchain_create_info.imageArrayLayers = image_array_layers; - swapchain_create_info.imageUsage = info.image_usage_flags; + swapchain_create_info.imageUsage = info.image_usage_flags; - if (info.graphics_queue_index != info.present_queue_index) { - swapchain_create_info.imageSharingMode = VK_SHARING_MODE_CONCURRENT; + if (info.graphics_queue_index != info.present_queue_index) + { + swapchain_create_info.imageSharingMode = VK_SHARING_MODE_CONCURRENT; swapchain_create_info.queueFamilyIndexCount = 2; - swapchain_create_info.pQueueFamilyIndices = queue_family_indices; - } else { + swapchain_create_info.pQueueFamilyIndices = queue_family_indices; + } + else + { swapchain_create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; } - swapchain_create_info.preTransform = pre_transform; + swapchain_create_info.preTransform = pre_transform; swapchain_create_info.compositeAlpha = info.composite_alpha; - swapchain_create_info.presentMode = present_mode; - swapchain_create_info.clipped = info.clipped; - swapchain_create_info.oldSwapchain = info.old_swapchain; - Swapchain swapchain{}; + swapchain_create_info.presentMode = present_mode; + swapchain_create_info.clipped = info.clipped; + swapchain_create_info.oldSwapchain = info.old_swapchain; + Swapchain swapchain{}; PFN_vkCreateSwapchainKHR swapchain_create_proc; detail::vulkan_functions().get_device_proc_addr(info.device, swapchain_create_proc, "vkCreateSwapchainKHR"); - auto res = swapchain_create_proc(info.device, &swapchain_create_info, info.allocation_callbacks, &swapchain.swapchain); + auto res = + swapchain_create_proc(info.device, &swapchain_create_info, info.allocation_callbacks, &swapchain.swapchain); - if (res != VK_SUCCESS) { + if (res != VK_SUCCESS) + { throw to_exception(SwapchainError::failed_create_swapchain, res); } - swapchain.device = info.device; - swapchain.image_format = surface_format.format; - swapchain.color_space = surface_format.colorSpace; + swapchain.device = info.device; + swapchain.image_format = surface_format.format; + swapchain.color_space = surface_format.colorSpace; swapchain.image_usage_flags = info.image_usage_flags; - swapchain.extent = extent; + swapchain.extent = extent; detail::vulkan_functions().get_device_proc_addr( info.device, swapchain.internal_table.fp_vkGetSwapchainImagesKHR, "vkGetSwapchainImagesKHR"); - detail::vulkan_functions().get_device_proc_addr(info.device, swapchain.internal_table.fp_vkCreateImageView, "vkCreateImageView"); - detail::vulkan_functions().get_device_proc_addr(info.device, swapchain.internal_table.fp_vkDestroyImageView, "vkDestroyImageView"); + detail::vulkan_functions().get_device_proc_addr( + info.device, swapchain.internal_table.fp_vkCreateImageView, "vkCreateImageView"); + detail::vulkan_functions().get_device_proc_addr( + info.device, swapchain.internal_table.fp_vkDestroyImageView, "vkDestroyImageView"); detail::vulkan_functions().get_device_proc_addr( info.device, swapchain.internal_table.fp_vkDestroySwapchainKHR, "vkDestroySwapchainKHR"); - auto images = swapchain.get_images(); + auto images = swapchain.get_images(); swapchain.requested_min_image_count = image_count; - swapchain.present_mode = present_mode; - swapchain.image_count = static_cast(images.size()); - swapchain.instance_version = info.instance_version; - swapchain.allocation_callbacks = info.allocation_callbacks; + swapchain.present_mode = present_mode; + swapchain.image_count = static_cast(images.size()); + swapchain.instance_version = info.instance_version; + swapchain.allocation_callbacks = info.allocation_callbacks; return swapchain; } -std::vector Swapchain::get_images() { +std::vector Swapchain::get_images() +{ std::vector swapchain_images; auto swapchain_images_ret = detail::get_vector(swapchain_images, internal_table.fp_vkGetSwapchainImagesKHR, device, swapchain); - if (swapchain_images_ret != VK_SUCCESS) { + if (swapchain_images_ret != VK_SUCCESS) + { throw to_exception(SwapchainError::failed_get_swapchain_images, swapchain_images_ret); } return swapchain_images; } -std::vector Swapchain::get_image_views() { return get_image_views(nullptr); } -std::vector Swapchain::get_image_views(const void* pNext) { +std::vector Swapchain::get_image_views() +{ + return get_image_views(nullptr); +} +std::vector Swapchain::get_image_views(const void* pNext) +{ const auto swapchain_images = get_images(); bool already_contains_image_view_usage = false; - while (pNext) { - if (reinterpret_cast(pNext)->sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO) { + while (pNext) + { + if (reinterpret_cast(pNext)->sType == VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO) + { already_contains_image_view_usage = true; break; } @@ -2070,180 +2527,219 @@ std::vector Swapchain::get_image_views(const void* pNext) { desired_flags.usage = image_usage_flags; std::vector views(swapchain_images.size()); - for (size_t i = 0; i < swapchain_images.size(); i++) { + for (size_t i = 0; i < swapchain_images.size(); i++) + { VkImageViewCreateInfo createInfo = {}; - createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; - if (instance_version >= VKB_VK_API_VERSION_1_1 && !already_contains_image_view_usage) { + createInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; + if (instance_version >= VKB_VK_API_VERSION_1_1 && !already_contains_image_view_usage) + { createInfo.pNext = &desired_flags; - } else { + } + else + { createInfo.pNext = pNext; } - createInfo.image = swapchain_images[i]; - createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; - createInfo.format = image_format; - createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY; - createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY; - createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY; - createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY; - createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; - createInfo.subresourceRange.baseMipLevel = 0; - createInfo.subresourceRange.levelCount = 1; + createInfo.image = swapchain_images[i]; + createInfo.viewType = VK_IMAGE_VIEW_TYPE_2D; + createInfo.format = image_format; + createInfo.components.r = VK_COMPONENT_SWIZZLE_IDENTITY; + createInfo.components.g = VK_COMPONENT_SWIZZLE_IDENTITY; + createInfo.components.b = VK_COMPONENT_SWIZZLE_IDENTITY; + createInfo.components.a = VK_COMPONENT_SWIZZLE_IDENTITY; + createInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + createInfo.subresourceRange.baseMipLevel = 0; + createInfo.subresourceRange.levelCount = 1; createInfo.subresourceRange.baseArrayLayer = 0; - createInfo.subresourceRange.layerCount = 1; + createInfo.subresourceRange.layerCount = 1; VkResult res = internal_table.fp_vkCreateImageView(device, &createInfo, allocation_callbacks, &views[i]); - if (res != VK_SUCCESS) throw to_exception(SwapchainError::failed_create_swapchain_image_views, res); + if (res != VK_SUCCESS) + throw to_exception(SwapchainError::failed_create_swapchain_image_views, res); } return views; } -void Swapchain::destroy_image_views(std::vector const& image_views) { - for (auto& image_view : image_views) { +void Swapchain::destroy_image_views(std::vector const& image_views) +{ + for (auto& image_view : image_views) + { internal_table.fp_vkDestroyImageView(device, image_view, allocation_callbacks); } } -Swapchain::operator VkSwapchainKHR() const { return this->swapchain; } -SwapchainBuilder& SwapchainBuilder::set_old_swapchain(VkSwapchainKHR old_swapchain) { +Swapchain::operator VkSwapchainKHR() const +{ + return this->swapchain; +} +SwapchainBuilder& SwapchainBuilder::set_old_swapchain(VkSwapchainKHR old_swapchain) +{ info.old_swapchain = old_swapchain; return *this; } -SwapchainBuilder& SwapchainBuilder::set_old_swapchain(Swapchain const& swapchain) { +SwapchainBuilder& SwapchainBuilder::set_old_swapchain(Swapchain const& swapchain) +{ info.old_swapchain = swapchain.swapchain; return *this; } -SwapchainBuilder& SwapchainBuilder::set_desired_extent(uint32_t width, uint32_t height) { - info.desired_width = width; +SwapchainBuilder& SwapchainBuilder::set_desired_extent(uint32_t width, uint32_t height) +{ + info.desired_width = width; info.desired_height = height; return *this; } -SwapchainBuilder& SwapchainBuilder::set_desired_format(VkSurfaceFormatKHR format) { +SwapchainBuilder& SwapchainBuilder::set_desired_format(VkSurfaceFormatKHR format) +{ info.desired_formats.insert(info.desired_formats.begin(), format); return *this; } -SwapchainBuilder& SwapchainBuilder::add_fallback_format(VkSurfaceFormatKHR format) { +SwapchainBuilder& SwapchainBuilder::add_fallback_format(VkSurfaceFormatKHR format) +{ info.desired_formats.push_back(format); return *this; } -SwapchainBuilder& SwapchainBuilder::use_default_format_selection() { +SwapchainBuilder& SwapchainBuilder::use_default_format_selection() +{ info.desired_formats.clear(); add_desired_formats(info.desired_formats); return *this; } -SwapchainBuilder& SwapchainBuilder::set_desired_present_mode(VkPresentModeKHR present_mode) { +SwapchainBuilder& SwapchainBuilder::set_desired_present_mode(VkPresentModeKHR present_mode) +{ info.desired_present_modes.insert(info.desired_present_modes.begin(), present_mode); return *this; } -SwapchainBuilder& SwapchainBuilder::add_fallback_present_mode(VkPresentModeKHR present_mode) { +SwapchainBuilder& SwapchainBuilder::add_fallback_present_mode(VkPresentModeKHR present_mode) +{ info.desired_present_modes.push_back(present_mode); return *this; } -SwapchainBuilder& SwapchainBuilder::use_default_present_mode_selection() { +SwapchainBuilder& SwapchainBuilder::use_default_present_mode_selection() +{ info.desired_present_modes.clear(); add_desired_present_modes(info.desired_present_modes); return *this; } -SwapchainBuilder& SwapchainBuilder::set_allocation_callbacks(VkAllocationCallbacks* callbacks) { +SwapchainBuilder& SwapchainBuilder::set_allocation_callbacks(VkAllocationCallbacks* callbacks) +{ info.allocation_callbacks = callbacks; return *this; } -SwapchainBuilder& SwapchainBuilder::set_image_usage_flags(VkImageUsageFlags usage_flags) { +SwapchainBuilder& SwapchainBuilder::set_image_usage_flags(VkImageUsageFlags usage_flags) +{ info.image_usage_flags = usage_flags; return *this; } -SwapchainBuilder& SwapchainBuilder::add_image_usage_flags(VkImageUsageFlags usage_flags) { +SwapchainBuilder& SwapchainBuilder::add_image_usage_flags(VkImageUsageFlags usage_flags) +{ info.image_usage_flags = info.image_usage_flags | usage_flags; return *this; } -SwapchainBuilder& SwapchainBuilder::use_default_image_usage_flags() { +SwapchainBuilder& SwapchainBuilder::use_default_image_usage_flags() +{ info.image_usage_flags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; return *this; } -SwapchainBuilder& SwapchainBuilder::set_image_array_layer_count(uint32_t array_layer_count) { +SwapchainBuilder& SwapchainBuilder::set_image_array_layer_count(uint32_t array_layer_count) +{ info.array_layer_count = array_layer_count; return *this; } -SwapchainBuilder& SwapchainBuilder::set_desired_min_image_count(uint32_t min_image_count) { +SwapchainBuilder& SwapchainBuilder::set_desired_min_image_count(uint32_t min_image_count) +{ info.min_image_count = min_image_count; return *this; } -SwapchainBuilder& SwapchainBuilder::set_required_min_image_count(uint32_t required_min_image_count) { +SwapchainBuilder& SwapchainBuilder::set_required_min_image_count(uint32_t required_min_image_count) +{ info.required_min_image_count = required_min_image_count; return *this; } -SwapchainBuilder& SwapchainBuilder::set_clipped(bool clipped) { +SwapchainBuilder& SwapchainBuilder::set_clipped(bool clipped) +{ info.clipped = clipped; return *this; } -SwapchainBuilder& SwapchainBuilder::set_create_flags(VkSwapchainCreateFlagBitsKHR create_flags) { +SwapchainBuilder& SwapchainBuilder::set_create_flags(VkSwapchainCreateFlagBitsKHR create_flags) +{ info.create_flags = create_flags; return *this; } -SwapchainBuilder& SwapchainBuilder::set_pre_transform_flags(VkSurfaceTransformFlagBitsKHR pre_transform_flags) { +SwapchainBuilder& SwapchainBuilder::set_pre_transform_flags(VkSurfaceTransformFlagBitsKHR pre_transform_flags) +{ info.pre_transform = pre_transform_flags; return *this; } -SwapchainBuilder& SwapchainBuilder::set_composite_alpha_flags(VkCompositeAlphaFlagBitsKHR composite_alpha_flags) { +SwapchainBuilder& SwapchainBuilder::set_composite_alpha_flags(VkCompositeAlphaFlagBitsKHR composite_alpha_flags) +{ info.composite_alpha = composite_alpha_flags; return *this; } -void SwapchainBuilder::add_desired_formats(std::vector& formats) const { +void SwapchainBuilder::add_desired_formats(std::vector& formats) const +{ formats.push_back({ VK_FORMAT_B8G8R8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR }); formats.push_back({ VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR }); } -void SwapchainBuilder::add_desired_present_modes(std::vector& modes) const { +void SwapchainBuilder::add_desired_present_modes(std::vector& modes) const +{ modes.push_back(VK_PRESENT_MODE_MAILBOX_KHR); modes.push_back(VK_PRESENT_MODE_FIFO_KHR); } -SDL_Window* create_window_sdl(const char* window_name, bool resizable, int width, int height) { - if (!SDL_Init(SDL_INIT_VIDEO)) throw sdl_exception(); +SDL_Window* create_window_sdl(const char* window_name, bool resizable, int width, int height) +{ + if (!SDL_Init(SDL_INIT_VIDEO)) + throw sdl_exception(); SDL_WindowFlags flags = 0; flags |= SDL_WINDOW_VULKAN; - if (resizable) flags |= SDL_WINDOW_RESIZABLE; + if (resizable) + flags |= SDL_WINDOW_RESIZABLE; auto window = SDL_CreateWindow(window_name, width, height, flags); - if (window == nullptr) throw sdl_exception(); + if (window == nullptr) + throw sdl_exception(); return window; } -void destroy_window_sdl(SDL_Window* window) { +void destroy_window_sdl(SDL_Window* window) +{ SDL_DestroyWindow(window); SDL_Quit(); } -VkSurfaceKHR create_surface_sdl(VkInstance instance, SDL_Window * window, VkAllocationCallbacks* allocator) { +VkSurfaceKHR create_surface_sdl(VkInstance instance, SDL_Window* window, VkAllocationCallbacks* allocator) +{ VkSurfaceKHR surface = VK_NULL_HANDLE; - if (!SDL_Vulkan_CreateSurface(window, instance, allocator, &surface)) { + if (!SDL_Vulkan_CreateSurface(window, instance, allocator, &surface)) + { surface = VK_NULL_HANDLE; throw sdl_exception(); } return surface; } -void create_swapchain(SwapchainBuilder& swapchain_builder, Swapchain& swapchain) { +void create_swapchain(SwapchainBuilder& swapchain_builder, Swapchain& swapchain) +{ auto new_swapchain = swapchain_builder.set_old_swapchain(swapchain).build(); destroy_swapchain(swapchain); swapchain = new_swapchain; } -VkCommandPool create_command_pool( - vkb::DispatchTable const& disp, - uint32_t queue_family_index -) { +VkCommandPool create_command_pool(vkb::DispatchTable const& disp, uint32_t queue_family_index) +{ VkCommandPoolCreateInfo pool_info = {}; - pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; - pool_info.queueFamilyIndex = queue_family_index; + pool_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO; + pool_info.queueFamilyIndex = queue_family_index; VkCommandPool command_pool; - auto result = disp.createCommandPool(&pool_info, nullptr, &command_pool); + auto result = disp.createCommandPool(&pool_info, nullptr, &command_pool); VERIFY_VK_RESULT("failed to create command pool", result); return command_pool; } -Sync create_sync_objects(Swapchain const& swapchain, vkb::DispatchTable const& disp, const int max_frames_in_flight) { +Sync create_sync_objects(Swapchain const& swapchain, vkb::DispatchTable const& disp, const int max_frames_in_flight) +{ Sync sync; sync.available_semaphores.resize(max_frames_in_flight); @@ -2252,13 +2748,14 @@ Sync create_sync_objects(Swapchain const& swapchain, vkb::DispatchTable const& d sync.image_in_flight.resize(swapchain.image_count, VK_NULL_HANDLE); VkSemaphoreCreateInfo semaphore_info = {}; - semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; + semaphore_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO; VkFenceCreateInfo fence_info = {}; - fence_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; - fence_info.flags = VK_FENCE_CREATE_SIGNALED_BIT; + fence_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO; + fence_info.flags = VK_FENCE_CREATE_SIGNALED_BIT; - for (size_t i = 0; i < max_frames_in_flight; i++) { + for (size_t i = 0; i < max_frames_in_flight; i++) + { VkResult result; result = disp.createSemaphore(&semaphore_info, nullptr, &sync.available_semaphores[i]); VERIFY_VK_RESULT("failed to create available semaphore", result); @@ -2270,14 +2767,16 @@ Sync create_sync_objects(Swapchain const& swapchain, vkb::DispatchTable const& d return sync; } -std::vector readFile(const std::string& filename) { +std::vector readFile(const std::string& filename) +{ std::ifstream file(filename, std::ios::ate | std::ios::binary); - if (!file.is_open()) { + if (!file.is_open()) + { throw std::runtime_error("failed to open file!"); } - size_t file_size = (size_t)file.tellg(); + size_t file_size = (size_t)file.tellg(); std::vector buffer(file_size); file.seekg(0); @@ -2288,25 +2787,28 @@ std::vector readFile(const std::string& filename) { return buffer; } -VkShaderModule createShaderModule(vkb::DispatchTable const& disp, const std::vector& code) { +VkShaderModule createShaderModule(vkb::DispatchTable const& disp, const std::vector& code) +{ VkShaderModuleCreateInfo create_info = {}; - create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; - create_info.codeSize = code.size(); - create_info.pCode = reinterpret_cast(code.data()); + create_info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO; + create_info.codeSize = code.size(); + create_info.pCode = reinterpret_cast(code.data()); VkShaderModule shaderModule; - auto result = disp.createShaderModule(&create_info, nullptr, &shaderModule); + auto result = disp.createShaderModule(&create_info, nullptr, &shaderModule); VERIFY_VK_RESULT("failed to create shader module", result); return shaderModule; } -VkShaderModule readShaderFromFile(vkb::DispatchTable const& disp, const std::string& filename) { +VkShaderModule readShaderFromFile(vkb::DispatchTable const& disp, const std::string& filename) +{ std::vector code = readFile(filename); return createShaderModule(disp, code); } -std::exception vulkan_exception(const char* message, VkResult result) { +std::exception vulkan_exception(const char* message, VkResult result) +{ std::string error_message; error_message.append(message); error_message.append(": "); @@ -2314,7 +2816,8 @@ std::exception vulkan_exception(const char* message, VkResult result) { return std::runtime_error(error_message); } -std::exception sdl_exception() { +std::exception sdl_exception() +{ return std::runtime_error(SDL_GetError()); } @@ -2348,11 +2851,12 @@ void device_initialization_phase_5(SwapchainBuilder& swapchain_builder, Init& in { create_swapchain(swapchain_builder, init.swapchain); - init.swapchain_images = init.swapchain.get_images(); + init.swapchain_images = init.swapchain.get_images(); init.swapchain_image_views = init.swapchain.get_image_views(); } -Init device_initialization(const std::string& window_name) { +Init device_initialization(const std::string& window_name) +{ Init init; device_initialization_phase_1(window_name, init); @@ -2372,7 +2876,8 @@ Init device_initialization(const std::string& window_name) { return init; } -void cleanup_init(Init& init) { +void cleanup_init(Init& init) +{ init.swapchain.destroy_image_views(init.swapchain_image_views); destroy_swapchain(init.swapchain); @@ -2382,14 +2887,16 @@ void cleanup_init(Init& init) { destroy_window_sdl(init.window); } -void recreate_init_swapchain(SwapchainBuilder& swapchain_builder, Init& init, bool wait_for_idle) { - if (wait_for_idle) init.disp.deviceWaitIdle(); +void recreate_init_swapchain(SwapchainBuilder& swapchain_builder, Init& init, bool wait_for_idle) +{ + if (wait_for_idle) + init.disp.deviceWaitIdle(); init.swapchain.destroy_image_views(init.swapchain_image_views); create_swapchain(swapchain_builder, init.swapchain); - init.swapchain_images = init.swapchain.get_images(); + init.swapchain_images = init.swapchain.get_images(); init.swapchain_image_views = init.swapchain.get_image_views(); } @@ -2415,12 +2922,15 @@ void TestAppBase::run(const std::string& window_name) this->setup(); - bool running = true; - int frame_num = 0; - while (running) { + bool running = true; + int frame_num = 0; + while (running) + { SDL_Event windowEvent; - while (SDL_PollEvent(&windowEvent)) { - if (windowEvent.type == SDL_EVENT_QUIT) { + while (SDL_PollEvent(&windowEvent)) + { + if (windowEvent.type == SDL_EVENT_QUIT) + { break; } } @@ -2445,7 +2955,8 @@ void TestAppBase::recreate_swapchain(bool wait_for_idle) void TestAppBase::setup() {} void TestAppBase::cleanup() {} -void TestAppBase::configure_instance_builder(InstanceBuilder& instance_builder) { +void TestAppBase::configure_instance_builder(InstanceBuilder& instance_builder) +{ instance_builder.use_default_debug_messenger().request_validation_layers(); } void TestAppBase::configure_physical_device_selector(PhysicalDeviceSelector& phys_device_selector) {} diff --git a/test/test_apps/common/test_app_base.h b/test/test_apps/common/test_app_base.h index 02048420f..4d134dbec 100644 --- a/test/test_apps/common/test_app_base.h +++ b/test/test_apps/common/test_app_base.h @@ -71,13 +71,16 @@ std::exception vulkan_exception(const char* message, VkResult result); std::exception sdl_exception(); GFXRECON_BEGIN_NAMESPACE(detail) -struct GenericFeaturesPNextNode { +struct GenericFeaturesPNextNode +{ static const uint32_t field_capacity = 256; GenericFeaturesPNextNode(); - template GenericFeaturesPNextNode(T const& features) noexcept { + template + GenericFeaturesPNextNode(T const& features) noexcept + { memset(fields, UINT8_MAX, sizeof(VkBool32) * field_capacity); memcpy(this, &features, sizeof(T)); } @@ -87,17 +90,22 @@ struct GenericFeaturesPNextNode { void combine(GenericFeaturesPNextNode const& right) noexcept; VkStructureType sType = static_cast(0); - void* pNext = nullptr; - VkBool32 fields[field_capacity]; + void* pNext = nullptr; + VkBool32 fields[field_capacity]; }; -struct GenericFeatureChain { +struct GenericFeatureChain +{ std::vector nodes; - template void add(T const& features) noexcept { + template + void add(T const& features) noexcept + { // If this struct is already in the list, combine it - for (auto& node : nodes) { - if (static_cast(features.sType) == node.sType) { + for (auto& node : nodes) + { + if (static_cast(features.sType) == node.sType) + { node.combine(features); return; } @@ -116,7 +124,8 @@ struct GenericFeatureChain { GFXRECON_END_NAMESPACE(detail) -enum class InstanceError { +enum class InstanceError +{ vulkan_unavailable, vulkan_version_unavailable, vulkan_version_1_1_unavailable, @@ -127,13 +136,15 @@ enum class InstanceError { requested_extensions_not_present, windowing_extensions_not_present, }; -enum class PhysicalDeviceError { +enum class PhysicalDeviceError +{ no_surface_provided, failed_enumerate_physical_devices, no_physical_devices_found, no_suitable_device, }; -enum class QueueError { +enum class QueueError +{ present_unavailable, graphics_unavailable, compute_unavailable, @@ -141,11 +152,13 @@ enum class QueueError { queue_index_out_of_range, invalid_queue_family_index }; -enum class DeviceError { +enum class DeviceError +{ failed_create_device, VkPhysicalDeviceFeatures2_in_pNext_chain_while_using_add_required_extension_features, }; -enum class SwapchainError { +enum class SwapchainError +{ surface_handle_not_provided, failed_query_surface_support_details, failed_create_swapchain, @@ -179,7 +192,8 @@ std::exception to_exception(SwapchainError err, VkResult result); // Gathers useful information about the available vulkan capabilities, like layers and instance // extensions. Use this for enabling features conditionally, ie if you would like an extension but // can use a fallback if it isn't supported but need to know if support is available first. -struct SystemInfo { +struct SystemInfo +{ private: SystemInfo(); @@ -193,10 +207,10 @@ struct SystemInfo { // Returns true if an extension is available bool is_extension_available(const char* extension_name) const; - std::vector available_layers; + std::vector available_layers; std::vector available_extensions; - bool validation_layers_available = false; - bool debug_utils_available = false; + bool validation_layers_available = false; + bool debug_utils_available = false; }; // Forward declared - check VkBoostrap.cpp for implementations @@ -204,11 +218,13 @@ const char* to_string_message_severity(VkDebugUtilsMessageSeverityFlagBitsEXT s) const char* to_string_message_type(VkDebugUtilsMessageTypeFlagsEXT s); // Default debug messenger -// Feel free to copy-paste it into your own code, change it as needed, then call `set_debug_callback()` to use that instead +// Feel free to copy-paste it into your own code, change it as needed, then call `set_debug_callback()` to use that +// instead inline VKAPI_ATTR VkBool32 VKAPI_CALL default_debug_callback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageType, + VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, - void*) { + void*) +{ auto ms = to_string_message_severity(messageSeverity); auto mt = to_string_message_type(messageType); printf("[%s: %s]\n%s\n", ms, mt, pCallbackData->pMessage); @@ -219,12 +235,13 @@ inline VKAPI_ATTR VkBool32 VKAPI_CALL default_debug_callback(VkDebugUtilsMessage class InstanceBuilder; class PhysicalDeviceSelector; -struct Instance { - VkInstance instance = VK_NULL_HANDLE; - VkDebugUtilsMessengerEXT debug_messenger = VK_NULL_HANDLE; - VkAllocationCallbacks* allocation_callbacks = VK_NULL_HANDLE; +struct Instance +{ + VkInstance instance = VK_NULL_HANDLE; + VkDebugUtilsMessengerEXT debug_messenger = VK_NULL_HANDLE; + VkAllocationCallbacks* allocation_callbacks = VK_NULL_HANDLE; PFN_vkGetInstanceProcAddr fp_vkGetInstanceProcAddr = nullptr; - PFN_vkGetDeviceProcAddr fp_vkGetDeviceProcAddr = nullptr; + PFN_vkGetDeviceProcAddr fp_vkGetDeviceProcAddr = nullptr; // A conversion function which allows this Instance to be used // in places where VkInstance would have been used. @@ -234,18 +251,20 @@ struct Instance { vkb::InstanceDispatchTable make_table() const; private: - bool headless = false; - bool properties2_ext_enabled = false; - uint32_t instance_version = VKB_VK_API_VERSION_1_0; - uint32_t api_version = VKB_VK_API_VERSION_1_0; + bool headless = false; + bool properties2_ext_enabled = false; + uint32_t instance_version = VKB_VK_API_VERSION_1_0; + uint32_t api_version = VKB_VK_API_VERSION_1_0; friend class InstanceBuilder; friend class PhysicalDeviceSelector; }; void destroy_surface(Instance const& instance, VkSurfaceKHR surface); // release surface handle -void destroy_surface(VkInstance instance, VkSurfaceKHR surface, VkAllocationCallbacks* callbacks = nullptr); // release surface handle -void destroy_instance(Instance const& instance); // release instance resources +void destroy_surface(VkInstance instance, + VkSurfaceKHR surface, + VkAllocationCallbacks* callbacks = nullptr); // release surface handle +void destroy_instance(Instance const& instance); // release instance resources /* If headless mode is false, by default vk-bootstrap use the following logic to enable the windowing extensions @@ -267,7 +286,8 @@ Use `InstanceBuilder::enable_extension()` to add new extensions without altering Feel free to make a PR or raise an issue to include additional platforms. */ -class InstanceBuilder { +class InstanceBuilder +{ public: // Default constructor, will load vulkan. explicit InstanceBuilder(); @@ -311,7 +331,8 @@ class InstanceBuilder { [[deprecated("Use require_api_version + set_minimum_instance_version instead.")]] InstanceBuilder& desire_api_version(uint32_t preferred_vulkan_version); - // Prefer a vulkan instance API version. If the desired version isn't available, it will use the highest version available. + // Prefer a vulkan instance API version. If the desired version isn't available, it will use the highest version + // available. [[deprecated("Use require_api_version + set_minimum_instance_version instead.")]] InstanceBuilder& desire_api_version(uint32_t major, uint32_t minor, uint32_t patch = 0); @@ -361,25 +382,26 @@ class InstanceBuilder { InstanceBuilder& set_allocation_callbacks(VkAllocationCallbacks* callbacks); private: - struct InstanceInfo { + struct InstanceInfo + { // VkApplicationInfo - const char* app_name = nullptr; - const char* engine_name = nullptr; - uint32_t application_version = 0; - uint32_t engine_version = 0; - uint32_t minimum_instance_version = 0; - uint32_t required_api_version = VKB_VK_API_VERSION_1_0; - uint32_t desired_api_version = VKB_VK_API_VERSION_1_0; + const char* app_name = nullptr; + const char* engine_name = nullptr; + uint32_t application_version = 0; + uint32_t engine_version = 0; + uint32_t minimum_instance_version = 0; + uint32_t required_api_version = VKB_VK_API_VERSION_1_0; + uint32_t desired_api_version = VKB_VK_API_VERSION_1_0; // VkInstanceCreateInfo - std::vector layers; - std::vector extensions; - VkInstanceCreateFlags flags = static_cast(0); + std::vector layers; + std::vector extensions; + VkInstanceCreateFlags flags = static_cast(0); std::vector pNext_elements; // debug callback - use the default so it is not nullptr PFN_vkDebugUtilsMessengerCallbackEXT debug_callback = default_debug_callback; - VkDebugUtilsMessageSeverityFlagsEXT debug_message_severity = + VkDebugUtilsMessageSeverityFlagsEXT debug_message_severity = VK_DEBUG_UTILS_MESSAGE_SEVERITY_WARNING_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_SEVERITY_ERROR_BIT_EXT; VkDebugUtilsMessageTypeFlagsEXT debug_message_type = VK_DEBUG_UTILS_MESSAGE_TYPE_GENERAL_BIT_EXT | VK_DEBUG_UTILS_MESSAGE_TYPE_VALIDATION_BIT_EXT | @@ -387,42 +409,45 @@ class InstanceBuilder { void* debug_user_data_pointer = nullptr; // validation features - std::vector disabled_validation_checks; - std::vector enabled_validation_features; + std::vector disabled_validation_checks; + std::vector enabled_validation_features; std::vector disabled_validation_features; // Custom allocator VkAllocationCallbacks* allocation_callbacks = VK_NULL_HANDLE; bool request_validation_layers = false; - bool enable_validation_layers = false; - bool use_debug_messenger = false; - bool headless_context = false; + bool enable_validation_layers = false; + bool use_debug_messenger = false; + bool headless_context = false; PFN_vkGetInstanceProcAddr fp_vkGetInstanceProcAddr = nullptr; } info; }; -VKAPI_ATTR VkBool32 VKAPI_CALL default_debug_callback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageType, +VKAPI_ATTR VkBool32 VKAPI_CALL default_debug_callback(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageType, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData, - void* pUserData); + void* pUserData); -void destroy_debug_utils_messenger( - VkInstance const instance, VkDebugUtilsMessengerEXT const messenger, VkAllocationCallbacks* allocation_callbacks = nullptr); +void destroy_debug_utils_messenger(VkInstance const instance, + VkDebugUtilsMessengerEXT const messenger, + VkAllocationCallbacks* allocation_callbacks = nullptr); // ---- Physical Device ---- // class PhysicalDeviceSelector; class DeviceBuilder; -struct PhysicalDevice { - std::string name; +struct PhysicalDevice +{ + std::string name; VkPhysicalDevice physical_device = VK_NULL_HANDLE; - VkSurfaceKHR surface = VK_NULL_HANDLE; + VkSurfaceKHR surface = VK_NULL_HANDLE; - // Note that this reflects selected features carried over from required features, not all features the physical device supports. - VkPhysicalDeviceFeatures features{}; - VkPhysicalDeviceProperties properties{}; + // Note that this reflects selected features carried over from required features, not all features the physical + // device supports. + VkPhysicalDeviceFeatures features{}; + VkPhysicalDeviceProperties properties{}; VkPhysicalDeviceMemoryProperties memory_properties{}; // Has a queue family that supports compute operations but not graphics nor transfer. @@ -448,7 +473,9 @@ struct PhysicalDevice { bool is_extension_present(const char* extension) const; // Returns true if all the features are present - template bool are_extension_features_present(T const& features) const { + template + bool are_extension_features_present(T const& features) const + { return is_features_node_present(detail::GenericFeaturesPNextNode(features)); } @@ -466,7 +493,9 @@ struct PhysicalDevice { // If the features from the provided features struct are all present, make all of the features be enable on the // device. Returns true if all of the features are present. - template bool enable_extension_features_if_present(T const& features_check) { + template + bool enable_extension_features_if_present(T const& features_check) + { return enable_features_node_if_present(detail::GenericFeaturesPNextNode(features_check)); } @@ -475,15 +504,20 @@ struct PhysicalDevice { operator VkPhysicalDevice() const; private: - uint32_t instance_version = VKB_VK_API_VERSION_1_0; - std::vector extensions_to_enable; - std::vector available_extensions; + uint32_t instance_version = VKB_VK_API_VERSION_1_0; + std::vector extensions_to_enable; + std::vector available_extensions; std::vector queue_families; - detail::GenericFeatureChain extended_features_chain; + detail::GenericFeatureChain extended_features_chain; bool defer_surface_initialization = false; - bool properties2_ext_enabled = false; - enum class Suitable { yes, partial, no }; + bool properties2_ext_enabled = false; + enum class Suitable + { + yes, + partial, + no + }; Suitable suitable = Suitable::yes; friend class PhysicalDeviceSelector; friend class DeviceBuilder; @@ -492,36 +526,48 @@ struct PhysicalDevice { bool enable_features_node_if_present(detail::GenericFeaturesPNextNode const& node); }; -enum class PreferredDeviceType { other = 0, integrated = 1, discrete = 2, virtual_gpu = 3, cpu = 4 }; +enum class PreferredDeviceType +{ + other = 0, + integrated = 1, + discrete = 2, + virtual_gpu = 3, + cpu = 4 +}; -enum class DeviceSelectionMode { +enum class DeviceSelectionMode +{ // return all suitable and partially suitable devices partially_and_fully_suitable, // return only physical devices which are fully suitable only_fully_suitable }; -// Enumerates the physical devices on the system, and based on the added criteria, returns a physical device or list of physical devies -// A device is considered suitable if it meets all the 'required' and 'desired' criteria. -// A device is considered partially suitable if it meets only the 'required' criteria. -class PhysicalDeviceSelector { +// Enumerates the physical devices on the system, and based on the added criteria, returns a physical device or list of +// physical devies A device is considered suitable if it meets all the 'required' and 'desired' criteria. A device is +// considered partially suitable if it meets only the 'required' criteria. +class PhysicalDeviceSelector +{ public: // Requires a gfxrecon::test::Instance to construct, needed to pass instance creation info. explicit PhysicalDeviceSelector(Instance const& instance); - // Requires a gfxrecon::test::Instance to construct, needed to pass instance creation info, optionally specify the surface here + // Requires a gfxrecon::test::Instance to construct, needed to pass instance creation info, optionally specify the + // surface here explicit PhysicalDeviceSelector(Instance const& instance, VkSurfaceKHR surface); // Return the first device which is suitable // use the `selection` parameter to configure if partially PhysicalDevice select(DeviceSelectionMode selection = DeviceSelectionMode::partially_and_fully_suitable) const; - // Return all devices which are considered suitable - intended for applications which want to let the user pick the physical device - std::vector select_devices( - DeviceSelectionMode selection = DeviceSelectionMode::partially_and_fully_suitable) const; + // Return all devices which are considered suitable - intended for applications which want to let the user pick the + // physical device + std::vector + select_devices(DeviceSelectionMode selection = DeviceSelectionMode::partially_and_fully_suitable) const; - // Return the names of all devices which are considered suitable - intended for applications which want to let the user pick the physical device - std::vector select_device_names( - DeviceSelectionMode selection = DeviceSelectionMode::partially_and_fully_suitable) const; + // Return the names of all devices which are considered suitable - intended for applications which want to let the + // user pick the physical device + std::vector + select_device_names(DeviceSelectionMode selection = DeviceSelectionMode::partially_and_fully_suitable) const; // Set the surface in which the physical device should render to. // Be sure to set it if swapchain functionality is to be used. @@ -579,7 +625,9 @@ class PhysicalDeviceSelector { // Require a physical device which supports a specific set of general/extension features. // If this function is used, the user should not put their own VkPhysicalDeviceFeatures2 in // the pNext chain of VkDeviceCreateInfo. - template PhysicalDeviceSelector& add_required_extension_features(T const& features) { + template + PhysicalDeviceSelector& add_required_extension_features(T const& features) + { criteria.extended_features_chain.add(features); return *this; } @@ -588,7 +636,8 @@ class PhysicalDeviceSelector { PhysicalDeviceSelector& set_required_features(VkPhysicalDeviceFeatures const& features); #if defined(VKB_VK_API_VERSION_1_2) // Require a physical device which supports the features in VkPhysicalDeviceVulkan11Features. - // Must have vulkan version 1.2 - This is due to the VkPhysicalDeviceVulkan11Features struct being added in 1.2, not 1.1 + // Must have vulkan version 1.2 - This is due to the VkPhysicalDeviceVulkan11Features struct being added in 1.2, + // not 1.1 PhysicalDeviceSelector& set_required_features_11(VkPhysicalDeviceVulkan11Features const& features_11); // Require a physical device which supports the features in VkPhysicalDeviceVulkan12Features. // Must have vulkan version 1.2 @@ -605,50 +654,53 @@ class PhysicalDeviceSelector { PhysicalDeviceSelector& defer_surface_initialization(); // Ignore all criteria and choose the first physical device that is available. - // Only use when: The first gpu in the list may be set by global user preferences and an application may wish to respect it. + // Only use when: The first gpu in the list may be set by global user preferences and an application may wish to + // respect it. PhysicalDeviceSelector& select_first_device_unconditionally(bool unconditionally = true); private: - struct InstanceInfo { - VkInstance instance = VK_NULL_HANDLE; - VkSurfaceKHR surface = VK_NULL_HANDLE; - uint32_t version = VKB_VK_API_VERSION_1_0; - bool headless = false; - bool properties2_ext_enabled = false; + struct InstanceInfo + { + VkInstance instance = VK_NULL_HANDLE; + VkSurfaceKHR surface = VK_NULL_HANDLE; + uint32_t version = VKB_VK_API_VERSION_1_0; + bool headless = false; + bool properties2_ext_enabled = false; } instance_info; // We copy the extension features stored in the selector criteria under the prose of a // "template" to ensure that after fetching everything is compared 1:1 during a match. - struct SelectionCriteria { - std::string name; - PreferredDeviceType preferred_type = PreferredDeviceType::discrete; - bool allow_any_type = true; - bool require_present = true; - bool require_dedicated_transfer_queue = false; - bool require_dedicated_compute_queue = false; - bool require_separate_transfer_queue = false; - bool require_separate_compute_queue = false; - VkDeviceSize required_mem_size = 0; - VkDeviceSize desired_mem_size = 0; + struct SelectionCriteria + { + std::string name; + PreferredDeviceType preferred_type = PreferredDeviceType::discrete; + bool allow_any_type = true; + bool require_present = true; + bool require_dedicated_transfer_queue = false; + bool require_dedicated_compute_queue = false; + bool require_separate_transfer_queue = false; + bool require_separate_compute_queue = false; + VkDeviceSize required_mem_size = 0; + VkDeviceSize desired_mem_size = 0; std::vector required_extensions; std::vector desired_extensions; uint32_t required_version = VKB_VK_API_VERSION_1_0; - uint32_t desired_version = VKB_VK_API_VERSION_1_0; + uint32_t desired_version = VKB_VK_API_VERSION_1_0; - VkPhysicalDeviceFeatures required_features{}; + VkPhysicalDeviceFeatures required_features{}; VkPhysicalDeviceFeatures2 required_features2{}; detail::GenericFeatureChain extended_features_chain; - bool defer_surface_initialization = false; - bool use_first_gpu_unconditionally = false; - bool enable_portability_subset = true; + bool defer_surface_initialization = false; + bool use_first_gpu_unconditionally = false; + bool enable_portability_subset = true; } criteria; - PhysicalDevice populate_device_details( - VkPhysicalDevice phys_device, detail::GenericFeatureChain const& src_extended_features_chain) const; + PhysicalDevice populate_device_details(VkPhysicalDevice phys_device, + detail::GenericFeatureChain const& src_extended_features_chain) const; PhysicalDevice::Suitable is_device_suitable(PhysicalDevice const& phys_device) const; @@ -656,18 +708,25 @@ class PhysicalDeviceSelector { }; // ---- Queue ---- // -enum class QueueType { present, graphics, compute, transfer }; +enum class QueueType +{ + present, + graphics, + compute, + transfer +}; // ---- Device ---- // -struct Device { - VkDevice device = VK_NULL_HANDLE; - PhysicalDevice physical_device; - VkSurfaceKHR surface = VK_NULL_HANDLE; +struct Device +{ + VkDevice device = VK_NULL_HANDLE; + PhysicalDevice physical_device; + VkSurfaceKHR surface = VK_NULL_HANDLE; std::vector queue_families; - VkAllocationCallbacks* allocation_callbacks = VK_NULL_HANDLE; - PFN_vkGetDeviceProcAddr fp_vkGetDeviceProcAddr = nullptr; - uint32_t instance_version = VKB_VK_API_VERSION_1_0; + VkAllocationCallbacks* allocation_callbacks = VK_NULL_HANDLE; + PFN_vkGetDeviceProcAddr fp_vkGetDeviceProcAddr = nullptr; + uint32_t instance_version = VKB_VK_API_VERSION_1_0; std::optional get_queue_index(QueueType type) const; // Only a compute or transfer queue type is valid. All other queue types do not support a 'dedicated' queue index @@ -685,25 +744,27 @@ struct Device { operator VkDevice() const; private: - struct { + struct + { PFN_vkGetDeviceQueue fp_vkGetDeviceQueue = nullptr; - PFN_vkDestroyDevice fp_vkDestroyDevice = nullptr; + PFN_vkDestroyDevice fp_vkDestroyDevice = nullptr; } internal_table; friend class DeviceBuilder; friend void destroy_device(Device const& device); }; - // For advanced device queue setup -struct CustomQueueDescription { +struct CustomQueueDescription +{ explicit CustomQueueDescription(uint32_t index, std::vector priorities); - uint32_t index = 0; + uint32_t index = 0; std::vector priorities; }; void destroy_device(Device const& device); -class DeviceBuilder { +class DeviceBuilder +{ public: // Any features and extensions that are requested/required in PhysicalDeviceSelector are automatically enabled. explicit DeviceBuilder(PhysicalDevice physical_device); @@ -716,7 +777,9 @@ class DeviceBuilder { // Add a structure to the pNext chain of VkDeviceCreateInfo. // The structure must be valid when DeviceBuilder::build() is called. - template DeviceBuilder& add_pNext(T* structure) { + template + DeviceBuilder& add_pNext(T* structure) + { info.pNext_chain.push_back(reinterpret_cast(structure)); return *this; } @@ -726,27 +789,32 @@ class DeviceBuilder { private: PhysicalDevice physical_device; - struct DeviceInfo { - VkDeviceCreateFlags flags = static_cast(0); - std::vector pNext_chain; + struct DeviceInfo + { + VkDeviceCreateFlags flags = static_cast(0); + std::vector pNext_chain; std::vector queue_descriptions; - VkAllocationCallbacks* allocation_callbacks = VK_NULL_HANDLE; + VkAllocationCallbacks* allocation_callbacks = VK_NULL_HANDLE; } info; }; // ---- Swapchain ---- // -struct Swapchain { - VkDevice device = VK_NULL_HANDLE; - VkSwapchainKHR swapchain = VK_NULL_HANDLE; - uint32_t image_count = 0; - VkFormat image_format = VK_FORMAT_UNDEFINED; // The image format actually used when creating the swapchain. - VkColorSpaceKHR color_space = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; // The color space actually used when creating the swapchain. +struct Swapchain +{ + VkDevice device = VK_NULL_HANDLE; + VkSwapchainKHR swapchain = VK_NULL_HANDLE; + uint32_t image_count = 0; + VkFormat image_format = VK_FORMAT_UNDEFINED; // The image format actually used when creating the swapchain. + VkColorSpaceKHR color_space = + VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; // The color space actually used when creating the swapchain. VkImageUsageFlags image_usage_flags = 0; - VkExtent2D extent = { 0, 0 }; - // The value of minImageCount actually used when creating the swapchain; note that the presentation engine is always free to create more images than that. - uint32_t requested_min_image_count = 0; - VkPresentModeKHR present_mode = VK_PRESENT_MODE_IMMEDIATE_KHR; // The present mode actually used when creating the swapchain. - uint32_t instance_version = VKB_VK_API_VERSION_1_0; + VkExtent2D extent = { 0, 0 }; + // The value of minImageCount actually used when creating the swapchain; note that the presentation engine is always + // free to create more images than that. + uint32_t requested_min_image_count = 0; + VkPresentModeKHR present_mode = + VK_PRESENT_MODE_IMMEDIATE_KHR; // The present mode actually used when creating the swapchain. + uint32_t instance_version = VKB_VK_API_VERSION_1_0; VkAllocationCallbacks* allocation_callbacks = VK_NULL_HANDLE; // Returns a vector of VkImage handles to the swapchain. @@ -757,18 +825,19 @@ struct Swapchain { // structure. std::vector get_image_views(); std::vector get_image_views(const void* pNext); - void destroy_image_views(std::vector const& image_views); + void destroy_image_views(std::vector const& image_views); // A conversion function which allows this Swapchain to be used // in places where VkSwapchainKHR would have been used. operator VkSwapchainKHR() const; private: - struct { + struct + { PFN_vkGetSwapchainImagesKHR fp_vkGetSwapchainImagesKHR = nullptr; - PFN_vkCreateImageView fp_vkCreateImageView = nullptr; - PFN_vkDestroyImageView fp_vkDestroyImageView = nullptr; - PFN_vkDestroySwapchainKHR fp_vkDestroySwapchainKHR = nullptr; + PFN_vkCreateImageView fp_vkCreateImageView = nullptr; + PFN_vkDestroyImageView fp_vkDestroyImageView = nullptr; + PFN_vkDestroySwapchainKHR fp_vkDestroySwapchainKHR = nullptr; } internal_table; friend class SwapchainBuilder; friend void destroy_swapchain(Swapchain const& swapchain); @@ -776,7 +845,8 @@ struct Swapchain { void destroy_swapchain(Swapchain const& swapchain); -class SwapchainBuilder { +class SwapchainBuilder +{ public: // Construct a SwapchainBuilder with a `gfxrecon::test::Device` explicit SwapchainBuilder(Device const& device); @@ -785,11 +855,11 @@ class SwapchainBuilder { // Construct a SwapchainBuilder with Vulkan handles for the physical device, device, and surface // Optionally can provide the uint32_t indices for the graphics and present queue // Note: The constructor will query the graphics & present queue if the indices are not provided - explicit SwapchainBuilder(VkPhysicalDevice const physical_device, - VkDevice const device, - VkSurfaceKHR const surface, + explicit SwapchainBuilder(VkPhysicalDevice const physical_device, + VkDevice const device, + VkSurfaceKHR const surface, std::optional graphics_queue_index = {}, - std::optional present_queue_index = {}); + std::optional present_queue_index = {}); Swapchain build() const; @@ -798,7 +868,6 @@ class SwapchainBuilder { SwapchainBuilder& set_old_swapchain(VkSwapchainKHR old_swapchain); SwapchainBuilder& set_old_swapchain(Swapchain const& swapchain); - // Desired size of the swapchain. By default, the swapchain will use the size // of the window being drawn to. SwapchainBuilder& set_desired_extent(uint32_t width, uint32_t height); @@ -820,7 +889,8 @@ class SwapchainBuilder { SwapchainBuilder& use_default_present_mode_selection(); // Set the bitmask of the image usage for acquired swapchain images. - // If the surface capabilities cannot allow it, building the swapchain will result in the `SwapchainError::required_usage_not_supported` error. + // If the surface capabilities cannot allow it, building the swapchain will result in the + // `SwapchainError::required_usage_not_supported` error. SwapchainBuilder& set_image_usage_flags(VkImageUsageFlags usage_flags); // Add a image usage to the bitmask for acquired swapchain images. SwapchainBuilder& add_image_usage_flags(VkImageUsageFlags usage_flags); @@ -834,7 +904,8 @@ class SwapchainBuilder { // Convenient named constants for passing to set_desired_min_image_count(). // Note that it is not an `enum class`, so its constants can be passed as an integer value without casting // In other words, these might as well be `static const int`, but they benefit from being grouped together this way. - enum BufferMode { + enum BufferMode + { SINGLE_BUFFERING = 1, DOUBLE_BUFFERING = 2, TRIPLE_BUFFERING = 3, @@ -843,13 +914,15 @@ class SwapchainBuilder { // Sets the desired minimum image count for the swapchain. // Note that the presentation engine is always free to create more images than requested. // You may pass one of the values specified in the BufferMode enum, or any integer value. - // For instance, if you pass DOUBLE_BUFFERING, the presentation engine is allowed to give you a double buffering setup, triple buffering, or more. This is up to the drivers. + // For instance, if you pass DOUBLE_BUFFERING, the presentation engine is allowed to give you a double buffering + // setup, triple buffering, or more. This is up to the drivers. SwapchainBuilder& set_desired_min_image_count(uint32_t min_image_count); // Sets a required minimum image count for the swapchain. - // If the surface capabilities cannot allow it, building the swapchain will result in the `SwapchainError::required_min_image_count_too_low` error. - // Otherwise, the same observations from set_desired_min_image_count() apply. - // A value of 0 is specially interpreted as meaning "no requirement", and is the behavior by default. + // If the surface capabilities cannot allow it, building the swapchain will result in the + // `SwapchainError::required_min_image_count_too_low` error. Otherwise, the same observations from + // set_desired_min_image_count() apply. A value of 0 is specially interpreted as meaning "no requirement", and is + // the behavior by default. SwapchainBuilder& set_required_min_image_count(uint32_t required_min_image_count); // Set whether the Vulkan implementation is allowed to discard rendering operations that @@ -863,12 +936,15 @@ class SwapchainBuilder { SwapchainBuilder& set_create_flags(VkSwapchainCreateFlagBitsKHR create_flags); // Set the transform to be applied, like a 90 degree rotation. Default is no transform. SwapchainBuilder& set_pre_transform_flags(VkSurfaceTransformFlagBitsKHR pre_transform_flags); - // Set the alpha channel to be used with other windows in on the system. Default is VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR. + // Set the alpha channel to be used with other windows in on the system. Default is + // VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR. SwapchainBuilder& set_composite_alpha_flags(VkCompositeAlphaFlagBitsKHR composite_alpha_flags); // Add a structure to the pNext chain of VkSwapchainCreateInfoKHR. // The structure must be valid when SwapchainBuilder::build() is called. - template SwapchainBuilder& add_pNext(T* structure) { + template + SwapchainBuilder& add_pNext(T* structure) + { info.pNext_chain.push_back(reinterpret_cast(structure)); return *this; } @@ -880,56 +956,58 @@ class SwapchainBuilder { void add_desired_formats(std::vector& formats) const; void add_desired_present_modes(std::vector& modes) const; - struct SwapchainInfo { - VkPhysicalDevice physical_device = VK_NULL_HANDLE; - VkDevice device = VK_NULL_HANDLE; + struct SwapchainInfo + { + VkPhysicalDevice physical_device = VK_NULL_HANDLE; + VkDevice device = VK_NULL_HANDLE; std::vector pNext_chain; - VkSwapchainCreateFlagBitsKHR create_flags = static_cast(0); - VkSurfaceKHR surface = VK_NULL_HANDLE; - std::vector desired_formats; - uint32_t instance_version = VKB_VK_API_VERSION_1_0; - uint32_t desired_width = 256; - uint32_t desired_height = 256; - uint32_t array_layer_count = 1; - uint32_t min_image_count = 0; - uint32_t required_min_image_count = 0; - VkImageUsageFlags image_usage_flags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; - std::optional graphics_queue_index = {}; - std::optional present_queue_index = {}; - VkSurfaceTransformFlagBitsKHR pre_transform = static_cast(0); + VkSwapchainCreateFlagBitsKHR create_flags = static_cast(0); + VkSurfaceKHR surface = VK_NULL_HANDLE; + std::vector desired_formats; + uint32_t instance_version = VKB_VK_API_VERSION_1_0; + uint32_t desired_width = 256; + uint32_t desired_height = 256; + uint32_t array_layer_count = 1; + uint32_t min_image_count = 0; + uint32_t required_min_image_count = 0; + VkImageUsageFlags image_usage_flags = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; + std::optional graphics_queue_index = {}; + std::optional present_queue_index = {}; + VkSurfaceTransformFlagBitsKHR pre_transform = static_cast(0); #if defined(__ANDROID__) VkCompositeAlphaFlagBitsKHR composite_alpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR; #else VkCompositeAlphaFlagBitsKHR composite_alpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; #endif std::vector desired_present_modes; - bool clipped = true; - VkSwapchainKHR old_swapchain = VK_NULL_HANDLE; - VkAllocationCallbacks* allocation_callbacks = VK_NULL_HANDLE; + bool clipped = true; + VkSwapchainKHR old_swapchain = VK_NULL_HANDLE; + VkAllocationCallbacks* allocation_callbacks = VK_NULL_HANDLE; } info; }; -SDL_Window* create_window_sdl(const char* window_name, bool resizable, int width, int height); -void destroy_window_sdl(SDL_Window * window); -VkSurfaceKHR create_surface_sdl(VkInstance instance, SDL_Window * window, VkAllocationCallbacks* allocator = nullptr); -void create_swapchain(SwapchainBuilder& swapchain_builder, Swapchain& swapchain); +SDL_Window* create_window_sdl(const char* window_name, bool resizable, int width, int height); +void destroy_window_sdl(SDL_Window* window); +VkSurfaceKHR create_surface_sdl(VkInstance instance, SDL_Window* window, VkAllocationCallbacks* allocator = nullptr); +void create_swapchain(SwapchainBuilder& swapchain_builder, Swapchain& swapchain); VkCommandPool create_command_pool(vkb::DispatchTable const& disp, uint32_t queue_family_index); -struct Sync { +struct Sync +{ std::vector available_semaphores; std::vector finished_semaphore; - std::vector in_flight_fences; - std::vector image_in_flight; + std::vector in_flight_fences; + std::vector image_in_flight; - Sync() = default; + Sync() = default; ~Sync() = default; - Sync(const Sync&) = delete; - Sync& operator =(const Sync&) = delete; + Sync(const Sync&) = delete; + Sync& operator=(const Sync&) = delete; - Sync(Sync&&) = default; - Sync& operator =(Sync&&) = default; + Sync(Sync&&) = default; + Sync& operator=(Sync&&) = default; }; Sync create_sync_objects(Swapchain const& swapchain, vkb::DispatchTable const& disp, const int max_frames_in_flight); @@ -940,19 +1018,24 @@ VkShaderModule createShaderModule(vkb::DispatchTable const& disp, const std::vec VkShaderModule readShaderFromFile(vkb::DispatchTable const& disp, const std::string& filename); -#define VERIFY_VK_RESULT(message, result) { if (result != VK_SUCCESS) throw gfxrecon::test::vulkan_exception(message, result); } +#define VERIFY_VK_RESULT(message, result) \ + { \ + if (result != VK_SUCCESS) \ + throw gfxrecon::test::vulkan_exception(message, result); \ + } -struct Init { - SDL_Window* window; - Instance instance; +struct Init +{ + SDL_Window* window; + Instance instance; vkb::InstanceDispatchTable inst_disp; - VkSurfaceKHR surface; - PhysicalDevice physical_device; - Device device; - vkb::DispatchTable disp; - Swapchain swapchain; - std::vector swapchain_images; - std::vector swapchain_image_views; + VkSurfaceKHR surface; + PhysicalDevice physical_device; + Device device; + vkb::DispatchTable disp; + Swapchain swapchain; + std::vector swapchain_images; + std::vector swapchain_image_views; }; Init device_initialization(const std::string& window_name); @@ -961,16 +1044,18 @@ void cleanup_init(Init& init); void recreate_init_swapchain(Init& init, bool wait_for_idle = true); -class TestAppBase { +class TestAppBase +{ public: void run(const std::string& window_name); + protected: - TestAppBase() = default; - ~TestAppBase() = default; - TestAppBase(const TestAppBase&) = delete; + TestAppBase() = default; + ~TestAppBase() = default; + TestAppBase(const TestAppBase&) = delete; TestAppBase& operator=(const TestAppBase&) = delete; - TestAppBase(TestAppBase&&) = delete; - TestAppBase& operator=(TestAppBase&&) = delete; + TestAppBase(TestAppBase&&) = delete; + TestAppBase& operator=(TestAppBase&&) = delete; void recreate_swapchain(bool wait_for_idle); diff --git a/test/test_apps/common/test_app_dispatch.h b/test/test_apps/common/test_app_dispatch.h index d14588a61..c5c0d60f7 100644 --- a/test/test_apps/common/test_app_dispatch.h +++ b/test/test_apps/common/test_app_dispatch.h @@ -5,1658 +5,2283 @@ * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated * documentation files (the “Software”), to deal in the Software without restriction, including without * limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies - * of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: + * of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following + * conditions: * - * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. + * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the + * Software. * * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT * LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, - * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE + * USE OR OTHER DEALINGS IN THE SOFTWARE. * */ // This file is a part of VkBootstrap // https://github.com/charles-lunarg/vk-bootstrap - #pragma once #include -namespace vkb { +namespace vkb +{ -struct InstanceDispatchTable { +struct InstanceDispatchTable +{ InstanceDispatchTable() = default; - InstanceDispatchTable(VkInstance instance, PFN_vkGetInstanceProcAddr procAddr) : instance(instance), populated(true) { + InstanceDispatchTable(VkInstance instance, PFN_vkGetInstanceProcAddr procAddr) : instance(instance), populated(true) + { fp_vkDestroyInstance = reinterpret_cast(procAddr(instance, "vkDestroyInstance")); - fp_vkEnumeratePhysicalDevices = reinterpret_cast(procAddr(instance, "vkEnumeratePhysicalDevices")); - fp_vkGetInstanceProcAddr = reinterpret_cast(procAddr(instance, "vkGetInstanceProcAddr")); - fp_vkGetPhysicalDeviceProperties = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceProperties")); - fp_vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties")); - fp_vkGetPhysicalDeviceMemoryProperties = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceMemoryProperties")); - fp_vkGetPhysicalDeviceFeatures = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceFeatures")); - fp_vkGetPhysicalDeviceFormatProperties = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceFormatProperties")); - fp_vkGetPhysicalDeviceImageFormatProperties = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceImageFormatProperties")); - fp_vkEnumerateDeviceLayerProperties = reinterpret_cast(procAddr(instance, "vkEnumerateDeviceLayerProperties")); - fp_vkEnumerateDeviceExtensionProperties = reinterpret_cast(procAddr(instance, "vkEnumerateDeviceExtensionProperties")); - fp_vkGetPhysicalDeviceSparseImageFormatProperties = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties")); + fp_vkEnumeratePhysicalDevices = + reinterpret_cast(procAddr(instance, "vkEnumeratePhysicalDevices")); + fp_vkGetInstanceProcAddr = + reinterpret_cast(procAddr(instance, "vkGetInstanceProcAddr")); + fp_vkGetPhysicalDeviceProperties = + reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceProperties")); + fp_vkGetPhysicalDeviceQueueFamilyProperties = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties")); + fp_vkGetPhysicalDeviceMemoryProperties = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceMemoryProperties")); + fp_vkGetPhysicalDeviceFeatures = + reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceFeatures")); + fp_vkGetPhysicalDeviceFormatProperties = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceFormatProperties")); + fp_vkGetPhysicalDeviceImageFormatProperties = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceImageFormatProperties")); + fp_vkEnumerateDeviceLayerProperties = reinterpret_cast( + procAddr(instance, "vkEnumerateDeviceLayerProperties")); + fp_vkEnumerateDeviceExtensionProperties = reinterpret_cast( + procAddr(instance, "vkEnumerateDeviceExtensionProperties")); + fp_vkGetPhysicalDeviceSparseImageFormatProperties = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties")); #if (defined(VK_KHR_android_surface)) - fp_vkCreateAndroidSurfaceKHR = reinterpret_cast(procAddr(instance, "vkCreateAndroidSurfaceKHR")); + fp_vkCreateAndroidSurfaceKHR = + reinterpret_cast(procAddr(instance, "vkCreateAndroidSurfaceKHR")); #endif #if (defined(VK_KHR_display)) - fp_vkGetPhysicalDeviceDisplayPropertiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceDisplayPropertiesKHR")); + fp_vkGetPhysicalDeviceDisplayPropertiesKHR = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceDisplayPropertiesKHR")); #endif #if (defined(VK_KHR_display)) - fp_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")); + fp_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")); #endif #if (defined(VK_KHR_display)) - fp_vkGetDisplayPlaneSupportedDisplaysKHR = reinterpret_cast(procAddr(instance, "vkGetDisplayPlaneSupportedDisplaysKHR")); + fp_vkGetDisplayPlaneSupportedDisplaysKHR = reinterpret_cast( + procAddr(instance, "vkGetDisplayPlaneSupportedDisplaysKHR")); #endif #if (defined(VK_KHR_display)) - fp_vkGetDisplayModePropertiesKHR = reinterpret_cast(procAddr(instance, "vkGetDisplayModePropertiesKHR")); + fp_vkGetDisplayModePropertiesKHR = + reinterpret_cast(procAddr(instance, "vkGetDisplayModePropertiesKHR")); #endif #if (defined(VK_KHR_display)) - fp_vkCreateDisplayModeKHR = reinterpret_cast(procAddr(instance, "vkCreateDisplayModeKHR")); + fp_vkCreateDisplayModeKHR = + reinterpret_cast(procAddr(instance, "vkCreateDisplayModeKHR")); #endif #if (defined(VK_KHR_display)) - fp_vkGetDisplayPlaneCapabilitiesKHR = reinterpret_cast(procAddr(instance, "vkGetDisplayPlaneCapabilitiesKHR")); + fp_vkGetDisplayPlaneCapabilitiesKHR = reinterpret_cast( + procAddr(instance, "vkGetDisplayPlaneCapabilitiesKHR")); #endif #if (defined(VK_KHR_display)) - fp_vkCreateDisplayPlaneSurfaceKHR = reinterpret_cast(procAddr(instance, "vkCreateDisplayPlaneSurfaceKHR")); + fp_vkCreateDisplayPlaneSurfaceKHR = + reinterpret_cast(procAddr(instance, "vkCreateDisplayPlaneSurfaceKHR")); #endif #if (defined(VK_KHR_surface)) fp_vkDestroySurfaceKHR = reinterpret_cast(procAddr(instance, "vkDestroySurfaceKHR")); #endif #if (defined(VK_KHR_surface)) - fp_vkGetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSurfaceSupportKHR")); + fp_vkGetPhysicalDeviceSurfaceSupportKHR = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceSurfaceSupportKHR")); #endif #if (defined(VK_KHR_surface)) - fp_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")); + fp_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")); #endif #if (defined(VK_KHR_surface)) - fp_vkGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR")); + fp_vkGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR")); #endif #if (defined(VK_KHR_surface)) - fp_vkGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR")); + fp_vkGetPhysicalDeviceSurfacePresentModesKHR = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceSurfacePresentModesKHR")); #endif #if (defined(VK_NN_vi_surface)) fp_vkCreateViSurfaceNN = reinterpret_cast(procAddr(instance, "vkCreateViSurfaceNN")); #endif #if (defined(VK_KHR_wayland_surface)) - fp_vkCreateWaylandSurfaceKHR = reinterpret_cast(procAddr(instance, "vkCreateWaylandSurfaceKHR")); + fp_vkCreateWaylandSurfaceKHR = + reinterpret_cast(procAddr(instance, "vkCreateWaylandSurfaceKHR")); #endif #if (defined(VK_KHR_wayland_surface)) - fp_vkGetPhysicalDeviceWaylandPresentationSupportKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR")); + fp_vkGetPhysicalDeviceWaylandPresentationSupportKHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR")); #endif #if (defined(VK_KHR_win32_surface)) - fp_vkCreateWin32SurfaceKHR = reinterpret_cast(procAddr(instance, "vkCreateWin32SurfaceKHR")); + fp_vkCreateWin32SurfaceKHR = + reinterpret_cast(procAddr(instance, "vkCreateWin32SurfaceKHR")); #endif #if (defined(VK_KHR_win32_surface)) - fp_vkGetPhysicalDeviceWin32PresentationSupportKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR")); + fp_vkGetPhysicalDeviceWin32PresentationSupportKHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR")); #endif #if (defined(VK_KHR_xlib_surface)) - fp_vkCreateXlibSurfaceKHR = reinterpret_cast(procAddr(instance, "vkCreateXlibSurfaceKHR")); + fp_vkCreateXlibSurfaceKHR = + reinterpret_cast(procAddr(instance, "vkCreateXlibSurfaceKHR")); #endif #if (defined(VK_KHR_xlib_surface)) - fp_vkGetPhysicalDeviceXlibPresentationSupportKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR")); + fp_vkGetPhysicalDeviceXlibPresentationSupportKHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR")); #endif #if (defined(VK_KHR_xcb_surface)) - fp_vkCreateXcbSurfaceKHR = reinterpret_cast(procAddr(instance, "vkCreateXcbSurfaceKHR")); + fp_vkCreateXcbSurfaceKHR = + reinterpret_cast(procAddr(instance, "vkCreateXcbSurfaceKHR")); #endif #if (defined(VK_KHR_xcb_surface)) - fp_vkGetPhysicalDeviceXcbPresentationSupportKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR")); + fp_vkGetPhysicalDeviceXcbPresentationSupportKHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR")); #endif #if (defined(VK_EXT_directfb_surface)) - fp_vkCreateDirectFBSurfaceEXT = reinterpret_cast(procAddr(instance, "vkCreateDirectFBSurfaceEXT")); + fp_vkCreateDirectFBSurfaceEXT = + reinterpret_cast(procAddr(instance, "vkCreateDirectFBSurfaceEXT")); #endif #if (defined(VK_EXT_directfb_surface)) - fp_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT")); + fp_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT")); #endif #if (defined(VK_FUCHSIA_imagepipe_surface)) - fp_vkCreateImagePipeSurfaceFUCHSIA = reinterpret_cast(procAddr(instance, "vkCreateImagePipeSurfaceFUCHSIA")); + fp_vkCreateImagePipeSurfaceFUCHSIA = reinterpret_cast( + procAddr(instance, "vkCreateImagePipeSurfaceFUCHSIA")); #endif #if (defined(VK_GGP_stream_descriptor_surface)) - fp_vkCreateStreamDescriptorSurfaceGGP = reinterpret_cast(procAddr(instance, "vkCreateStreamDescriptorSurfaceGGP")); + fp_vkCreateStreamDescriptorSurfaceGGP = reinterpret_cast( + procAddr(instance, "vkCreateStreamDescriptorSurfaceGGP")); #endif #if (defined(VK_QNX_screen_surface)) - fp_vkCreateScreenSurfaceQNX = reinterpret_cast(procAddr(instance, "vkCreateScreenSurfaceQNX")); + fp_vkCreateScreenSurfaceQNX = + reinterpret_cast(procAddr(instance, "vkCreateScreenSurfaceQNX")); #endif #if (defined(VK_QNX_screen_surface)) - fp_vkGetPhysicalDeviceScreenPresentationSupportQNX = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX")); + fp_vkGetPhysicalDeviceScreenPresentationSupportQNX = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX")); #endif #if (defined(VK_EXT_debug_report)) - fp_vkCreateDebugReportCallbackEXT = reinterpret_cast(procAddr(instance, "vkCreateDebugReportCallbackEXT")); + fp_vkCreateDebugReportCallbackEXT = + reinterpret_cast(procAddr(instance, "vkCreateDebugReportCallbackEXT")); #endif #if (defined(VK_EXT_debug_report)) - fp_vkDestroyDebugReportCallbackEXT = reinterpret_cast(procAddr(instance, "vkDestroyDebugReportCallbackEXT")); + fp_vkDestroyDebugReportCallbackEXT = reinterpret_cast( + procAddr(instance, "vkDestroyDebugReportCallbackEXT")); #endif #if (defined(VK_EXT_debug_report)) - fp_vkDebugReportMessageEXT = reinterpret_cast(procAddr(instance, "vkDebugReportMessageEXT")); + fp_vkDebugReportMessageEXT = + reinterpret_cast(procAddr(instance, "vkDebugReportMessageEXT")); #endif #if (defined(VK_NV_external_memory_capabilities)) - fp_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV")); + fp_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkGetPhysicalDeviceFeatures2 = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceFeatures2")); + fp_vkGetPhysicalDeviceFeatures2 = + reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceFeatures2")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkGetPhysicalDeviceProperties2 = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceProperties2")); + fp_vkGetPhysicalDeviceProperties2 = + reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceProperties2")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkGetPhysicalDeviceFormatProperties2 = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceFormatProperties2")); + fp_vkGetPhysicalDeviceFormatProperties2 = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceFormatProperties2")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkGetPhysicalDeviceImageFormatProperties2 = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceImageFormatProperties2")); + fp_vkGetPhysicalDeviceImageFormatProperties2 = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceImageFormatProperties2")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkGetPhysicalDeviceQueueFamilyProperties2 = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2")); + fp_vkGetPhysicalDeviceQueueFamilyProperties2 = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkGetPhysicalDeviceMemoryProperties2 = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceMemoryProperties2")); + fp_vkGetPhysicalDeviceMemoryProperties2 = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceMemoryProperties2")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkGetPhysicalDeviceSparseImageFormatProperties2 = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2")); + fp_vkGetPhysicalDeviceSparseImageFormatProperties2 = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkGetPhysicalDeviceExternalBufferProperties = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceExternalBufferProperties")); + fp_vkGetPhysicalDeviceExternalBufferProperties = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceExternalBufferProperties")); #endif #if (defined(VK_NV_external_memory_sci_buf)) - fp_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV")); + fp_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV")); #endif #if (defined(VK_NV_external_memory_sci_buf)) - fp_vkGetPhysicalDeviceSciBufAttributesNV = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSciBufAttributesNV")); + fp_vkGetPhysicalDeviceSciBufAttributesNV = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceSciBufAttributesNV")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkGetPhysicalDeviceExternalSemaphoreProperties = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceExternalSemaphoreProperties")); + fp_vkGetPhysicalDeviceExternalSemaphoreProperties = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceExternalSemaphoreProperties")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkGetPhysicalDeviceExternalFenceProperties = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceExternalFenceProperties")); + fp_vkGetPhysicalDeviceExternalFenceProperties = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceExternalFenceProperties")); #endif #if (defined(VK_NV_external_sci_sync)) || (defined(VK_NV_external_sci_sync2)) - fp_vkGetPhysicalDeviceSciSyncAttributesNV = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSciSyncAttributesNV")); + fp_vkGetPhysicalDeviceSciSyncAttributesNV = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceSciSyncAttributesNV")); #endif #if (defined(VK_EXT_direct_mode_display)) fp_vkReleaseDisplayEXT = reinterpret_cast(procAddr(instance, "vkReleaseDisplayEXT")); #endif #if (defined(VK_EXT_acquire_xlib_display)) - fp_vkAcquireXlibDisplayEXT = reinterpret_cast(procAddr(instance, "vkAcquireXlibDisplayEXT")); + fp_vkAcquireXlibDisplayEXT = + reinterpret_cast(procAddr(instance, "vkAcquireXlibDisplayEXT")); #endif #if (defined(VK_EXT_acquire_xlib_display)) - fp_vkGetRandROutputDisplayEXT = reinterpret_cast(procAddr(instance, "vkGetRandROutputDisplayEXT")); + fp_vkGetRandROutputDisplayEXT = + reinterpret_cast(procAddr(instance, "vkGetRandROutputDisplayEXT")); #endif #if (defined(VK_NV_acquire_winrt_display)) - fp_vkAcquireWinrtDisplayNV = reinterpret_cast(procAddr(instance, "vkAcquireWinrtDisplayNV")); + fp_vkAcquireWinrtDisplayNV = + reinterpret_cast(procAddr(instance, "vkAcquireWinrtDisplayNV")); #endif #if (defined(VK_NV_acquire_winrt_display)) fp_vkGetWinrtDisplayNV = reinterpret_cast(procAddr(instance, "vkGetWinrtDisplayNV")); #endif #if (defined(VK_EXT_display_surface_counter)) - fp_vkGetPhysicalDeviceSurfaceCapabilities2EXT = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")); + fp_vkGetPhysicalDeviceSurfaceCapabilities2EXT = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilities2EXT")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkEnumeratePhysicalDeviceGroups = reinterpret_cast(procAddr(instance, "vkEnumeratePhysicalDeviceGroups")); + fp_vkEnumeratePhysicalDeviceGroups = reinterpret_cast( + procAddr(instance, "vkEnumeratePhysicalDeviceGroups")); #endif #if (defined(VK_KHR_swapchain)) || (defined(VK_KHR_device_group)) - fp_vkGetPhysicalDevicePresentRectanglesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDevicePresentRectanglesKHR")); + fp_vkGetPhysicalDevicePresentRectanglesKHR = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDevicePresentRectanglesKHR")); #endif #if (defined(VK_MVK_ios_surface)) - fp_vkCreateIOSSurfaceMVK = reinterpret_cast(procAddr(instance, "vkCreateIOSSurfaceMVK")); + fp_vkCreateIOSSurfaceMVK = + reinterpret_cast(procAddr(instance, "vkCreateIOSSurfaceMVK")); #endif #if (defined(VK_MVK_macos_surface)) - fp_vkCreateMacOSSurfaceMVK = reinterpret_cast(procAddr(instance, "vkCreateMacOSSurfaceMVK")); + fp_vkCreateMacOSSurfaceMVK = + reinterpret_cast(procAddr(instance, "vkCreateMacOSSurfaceMVK")); #endif #if (defined(VK_EXT_metal_surface)) - fp_vkCreateMetalSurfaceEXT = reinterpret_cast(procAddr(instance, "vkCreateMetalSurfaceEXT")); + fp_vkCreateMetalSurfaceEXT = + reinterpret_cast(procAddr(instance, "vkCreateMetalSurfaceEXT")); #endif #if (defined(VK_EXT_sample_locations)) - fp_vkGetPhysicalDeviceMultisamplePropertiesEXT = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT")); + fp_vkGetPhysicalDeviceMultisamplePropertiesEXT = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT")); #endif #if (defined(VK_KHR_get_surface_capabilities2)) - fp_vkGetPhysicalDeviceSurfaceCapabilities2KHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR")); + fp_vkGetPhysicalDeviceSurfaceCapabilities2KHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR")); #endif #if (defined(VK_KHR_get_surface_capabilities2)) - fp_vkGetPhysicalDeviceSurfaceFormats2KHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSurfaceFormats2KHR")); + fp_vkGetPhysicalDeviceSurfaceFormats2KHR = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceSurfaceFormats2KHR")); #endif #if (defined(VK_KHR_get_display_properties2)) - fp_vkGetPhysicalDeviceDisplayProperties2KHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceDisplayProperties2KHR")); + fp_vkGetPhysicalDeviceDisplayProperties2KHR = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceDisplayProperties2KHR")); #endif #if (defined(VK_KHR_get_display_properties2)) - fp_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")); + fp_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")); #endif #if (defined(VK_KHR_get_display_properties2)) - fp_vkGetDisplayModeProperties2KHR = reinterpret_cast(procAddr(instance, "vkGetDisplayModeProperties2KHR")); + fp_vkGetDisplayModeProperties2KHR = + reinterpret_cast(procAddr(instance, "vkGetDisplayModeProperties2KHR")); #endif #if (defined(VK_KHR_get_display_properties2)) - fp_vkGetDisplayPlaneCapabilities2KHR = reinterpret_cast(procAddr(instance, "vkGetDisplayPlaneCapabilities2KHR")); + fp_vkGetDisplayPlaneCapabilities2KHR = reinterpret_cast( + procAddr(instance, "vkGetDisplayPlaneCapabilities2KHR")); #endif #if (defined(VK_KHR_calibrated_timestamps)) - fp_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR")); + fp_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsKHR")); #endif #if (defined(VK_EXT_debug_utils)) - fp_vkCreateDebugUtilsMessengerEXT = reinterpret_cast(procAddr(instance, "vkCreateDebugUtilsMessengerEXT")); + fp_vkCreateDebugUtilsMessengerEXT = + reinterpret_cast(procAddr(instance, "vkCreateDebugUtilsMessengerEXT")); #endif #if (defined(VK_EXT_debug_utils)) - fp_vkDestroyDebugUtilsMessengerEXT = reinterpret_cast(procAddr(instance, "vkDestroyDebugUtilsMessengerEXT")); + fp_vkDestroyDebugUtilsMessengerEXT = reinterpret_cast( + procAddr(instance, "vkDestroyDebugUtilsMessengerEXT")); #endif #if (defined(VK_EXT_debug_utils)) - fp_vkSubmitDebugUtilsMessageEXT = reinterpret_cast(procAddr(instance, "vkSubmitDebugUtilsMessageEXT")); + fp_vkSubmitDebugUtilsMessageEXT = + reinterpret_cast(procAddr(instance, "vkSubmitDebugUtilsMessageEXT")); #endif #if (defined(VK_NV_cooperative_matrix)) - fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV")); + fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV")); #endif #if (defined(VK_EXT_full_screen_exclusive)) - fp_vkGetPhysicalDeviceSurfacePresentModes2EXT = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT")); + fp_vkGetPhysicalDeviceSurfacePresentModes2EXT = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT")); #endif #if (defined(VK_KHR_performance_query)) - fp_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = reinterpret_cast(procAddr(instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR")); + fp_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = + reinterpret_cast( + procAddr(instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR")); #endif #if (defined(VK_KHR_performance_query)) - fp_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR")); + fp_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR")); #endif #if (defined(VK_EXT_headless_surface)) - fp_vkCreateHeadlessSurfaceEXT = reinterpret_cast(procAddr(instance, "vkCreateHeadlessSurfaceEXT")); + fp_vkCreateHeadlessSurfaceEXT = + reinterpret_cast(procAddr(instance, "vkCreateHeadlessSurfaceEXT")); #endif #if (defined(VK_NV_coverage_reduction_mode)) - fp_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV")); + fp_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkGetPhysicalDeviceToolProperties = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceToolProperties")); + fp_vkGetPhysicalDeviceToolProperties = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceToolProperties")); #endif #if (defined(VK_KHR_object_refresh)) - fp_vkGetPhysicalDeviceRefreshableObjectTypesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceRefreshableObjectTypesKHR")); + fp_vkGetPhysicalDeviceRefreshableObjectTypesKHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceRefreshableObjectTypesKHR")); #endif #if (defined(VK_KHR_fragment_shading_rate)) - fp_vkGetPhysicalDeviceFragmentShadingRatesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR")); + fp_vkGetPhysicalDeviceFragmentShadingRatesKHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR")); #endif #if (defined(VK_KHR_video_queue)) - fp_vkGetPhysicalDeviceVideoCapabilitiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR")); + fp_vkGetPhysicalDeviceVideoCapabilitiesKHR = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR")); #endif #if (defined(VK_KHR_video_queue)) - fp_vkGetPhysicalDeviceVideoFormatPropertiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR")); + fp_vkGetPhysicalDeviceVideoFormatPropertiesKHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR")); #endif #if (defined(VK_KHR_video_encode_queue)) - fp_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR")); + fp_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR")); #endif #if (defined(VK_EXT_acquire_drm_display)) - fp_vkAcquireDrmDisplayEXT = reinterpret_cast(procAddr(instance, "vkAcquireDrmDisplayEXT")); + fp_vkAcquireDrmDisplayEXT = + reinterpret_cast(procAddr(instance, "vkAcquireDrmDisplayEXT")); #endif #if (defined(VK_EXT_acquire_drm_display)) fp_vkGetDrmDisplayEXT = reinterpret_cast(procAddr(instance, "vkGetDrmDisplayEXT")); #endif #if (defined(VK_NV_optical_flow)) - fp_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV")); + fp_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceOpticalFlowImageFormatsNV")); #endif #if (defined(VK_KHR_cooperative_matrix)) - fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR")); + fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR")); #endif #if (defined(VK_KHR_get_physical_device_properties2)) - fp_vkGetPhysicalDeviceFeatures2KHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceFeatures2KHR")); + fp_vkGetPhysicalDeviceFeatures2KHR = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceFeatures2KHR")); #endif #if (defined(VK_KHR_get_physical_device_properties2)) - fp_vkGetPhysicalDeviceProperties2KHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceProperties2KHR")); + fp_vkGetPhysicalDeviceProperties2KHR = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceProperties2KHR")); #endif #if (defined(VK_KHR_get_physical_device_properties2)) - fp_vkGetPhysicalDeviceFormatProperties2KHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceFormatProperties2KHR")); + fp_vkGetPhysicalDeviceFormatProperties2KHR = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceFormatProperties2KHR")); #endif #if (defined(VK_KHR_get_physical_device_properties2)) - fp_vkGetPhysicalDeviceImageFormatProperties2KHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceImageFormatProperties2KHR")); + fp_vkGetPhysicalDeviceImageFormatProperties2KHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceImageFormatProperties2KHR")); #endif #if (defined(VK_KHR_get_physical_device_properties2)) - fp_vkGetPhysicalDeviceQueueFamilyProperties2KHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")); + fp_vkGetPhysicalDeviceQueueFamilyProperties2KHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2KHR")); #endif #if (defined(VK_KHR_get_physical_device_properties2)) - fp_vkGetPhysicalDeviceMemoryProperties2KHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceMemoryProperties2KHR")); + fp_vkGetPhysicalDeviceMemoryProperties2KHR = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceMemoryProperties2KHR")); #endif #if (defined(VK_KHR_get_physical_device_properties2)) - fp_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")); + fp_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2KHR")); #endif #if (defined(VK_KHR_external_memory_capabilities)) - fp_vkGetPhysicalDeviceExternalBufferPropertiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")); + fp_vkGetPhysicalDeviceExternalBufferPropertiesKHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceExternalBufferPropertiesKHR")); #endif #if (defined(VK_KHR_external_semaphore_capabilities)) - fp_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")); + fp_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceExternalSemaphorePropertiesKHR")); #endif #if (defined(VK_KHR_external_fence_capabilities)) - fp_vkGetPhysicalDeviceExternalFencePropertiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR")); + fp_vkGetPhysicalDeviceExternalFencePropertiesKHR = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceExternalFencePropertiesKHR")); #endif #if (defined(VK_KHR_device_group_creation)) - fp_vkEnumeratePhysicalDeviceGroupsKHR = reinterpret_cast(procAddr(instance, "vkEnumeratePhysicalDeviceGroupsKHR")); + fp_vkEnumeratePhysicalDeviceGroupsKHR = reinterpret_cast( + procAddr(instance, "vkEnumeratePhysicalDeviceGroupsKHR")); #endif #if (defined(VK_EXT_calibrated_timestamps)) - fp_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT")); + fp_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = + reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT")); #endif #if (defined(VK_EXT_tooling_info)) - fp_vkGetPhysicalDeviceToolPropertiesEXT = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceToolPropertiesEXT")); + fp_vkGetPhysicalDeviceToolPropertiesEXT = reinterpret_cast( + procAddr(instance, "vkGetPhysicalDeviceToolPropertiesEXT")); #endif } - void destroyInstance(const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyInstance(const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyInstance(instance, pAllocator); } - VkResult enumeratePhysicalDevices(uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const noexcept { + VkResult enumeratePhysicalDevices(uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const noexcept + { return fp_vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); } - PFN_vkVoidFunction getInstanceProcAddr(const char* pName) const noexcept { + PFN_vkVoidFunction getInstanceProcAddr(const char* pName) const noexcept + { return fp_vkGetInstanceProcAddr(instance, pName); } - void getPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) const noexcept { + void getPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties) const noexcept + { fp_vkGetPhysicalDeviceProperties(physicalDevice, pProperties); } - void getPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) const noexcept { + void getPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties) const noexcept + { fp_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); } - void getPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) const noexcept { + void getPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties) const noexcept + { fp_vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); } - void getPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) const noexcept { + void getPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) const noexcept + { fp_vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures); } - void getPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) const noexcept { + void getPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties) const noexcept + { fp_vkGetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); } - VkResult getPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) const noexcept { - return fp_vkGetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); - } - VkResult enumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) const noexcept { + VkResult getPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkImageFormatProperties* pImageFormatProperties) const noexcept + { + return fp_vkGetPhysicalDeviceImageFormatProperties( + physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); + } + VkResult enumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkLayerProperties* pProperties) const noexcept + { return fp_vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties); } - VkResult enumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) const noexcept { + VkResult enumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties) const noexcept + { return fp_vkEnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties); } - void getPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) const noexcept { - fp_vkGetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); + void getPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkSampleCountFlagBits samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties* pProperties) const noexcept + { + fp_vkGetPhysicalDeviceSparseImageFormatProperties( + physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); } #if (defined(VK_KHR_android_surface)) - VkResult createAndroidSurfaceKHR(const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const noexcept { + VkResult createAndroidSurfaceKHR(const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const noexcept + { return fp_vkCreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); } #endif #if (defined(VK_KHR_display)) - VkResult getPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPropertiesKHR* pProperties) const noexcept { + VkResult getPhysicalDeviceDisplayPropertiesKHR(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPropertiesKHR* pProperties) const noexcept + { return fp_vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties); } #endif #if (defined(VK_KHR_display)) - VkResult getPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlanePropertiesKHR* pProperties) const noexcept { + VkResult getPhysicalDeviceDisplayPlanePropertiesKHR(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlanePropertiesKHR* pProperties) const noexcept + { return fp_vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, pPropertyCount, pProperties); } #endif #if (defined(VK_KHR_display)) - VkResult getDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, uint32_t planeIndex, uint32_t* pDisplayCount, VkDisplayKHR* pDisplays) const noexcept { + VkResult getDisplayPlaneSupportedDisplaysKHR(VkPhysicalDevice physicalDevice, + uint32_t planeIndex, + uint32_t* pDisplayCount, + VkDisplayKHR* pDisplays) const noexcept + { return fp_vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, planeIndex, pDisplayCount, pDisplays); } #endif #if (defined(VK_KHR_display)) - VkResult getDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModePropertiesKHR* pProperties) const noexcept { + VkResult getDisplayModePropertiesKHR(VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModePropertiesKHR* pProperties) const noexcept + { return fp_vkGetDisplayModePropertiesKHR(physicalDevice, display, pPropertyCount, pProperties); } #endif #if (defined(VK_KHR_display)) - VkResult createDisplayModeKHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, const VkDisplayModeCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDisplayModeKHR* pMode) const noexcept { + VkResult createDisplayModeKHR(VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + const VkDisplayModeCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDisplayModeKHR* pMode) const noexcept + { return fp_vkCreateDisplayModeKHR(physicalDevice, display, pCreateInfo, pAllocator, pMode); } #endif #if (defined(VK_KHR_display)) - VkResult getDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkDisplayModeKHR mode, uint32_t planeIndex, VkDisplayPlaneCapabilitiesKHR* pCapabilities) const noexcept { + VkResult getDisplayPlaneCapabilitiesKHR(VkPhysicalDevice physicalDevice, + VkDisplayModeKHR mode, + uint32_t planeIndex, + VkDisplayPlaneCapabilitiesKHR* pCapabilities) const noexcept + { return fp_vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode, planeIndex, pCapabilities); } #endif #if (defined(VK_KHR_display)) - VkResult createDisplayPlaneSurfaceKHR(const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const noexcept { + VkResult createDisplayPlaneSurfaceKHR(const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const noexcept + { return fp_vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); } #endif #if (defined(VK_KHR_surface)) - void destroySurfaceKHR(VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroySurfaceKHR(VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroySurfaceKHR(instance, surface, pAllocator); } #endif #if (defined(VK_KHR_surface)) - VkResult getPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) const noexcept { + VkResult getPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32* pSupported) const noexcept + { return fp_vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); } #endif #if (defined(VK_KHR_surface)) - VkResult getPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) const noexcept { + VkResult getPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) const noexcept + { return fp_vkGetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); } #endif #if (defined(VK_KHR_surface)) - VkResult getPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) const noexcept { + VkResult getPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats) const noexcept + { return fp_vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); } #endif #if (defined(VK_KHR_surface)) - VkResult getPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) const noexcept { + VkResult getPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes) const noexcept + { return fp_vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); } #endif #if (defined(VK_NN_vi_surface)) - VkResult createViSurfaceNN(const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const noexcept { + VkResult createViSurfaceNN(const VkViSurfaceCreateInfoNN* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const noexcept + { return fp_vkCreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface); } #endif #if (defined(VK_KHR_wayland_surface)) - VkResult createWaylandSurfaceKHR(const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const noexcept { + VkResult createWaylandSurfaceKHR(const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const noexcept + { return fp_vkCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); } #endif #if (defined(VK_KHR_wayland_surface)) - VkBool32 getPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct wl_display* display) const noexcept { + VkBool32 getPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct wl_display* display) const noexcept + { return fp_vkGetPhysicalDeviceWaylandPresentationSupportKHR(physicalDevice, queueFamilyIndex, display); } #endif #if (defined(VK_KHR_win32_surface)) - VkResult createWin32SurfaceKHR(const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const noexcept { + VkResult createWin32SurfaceKHR(const VkWin32SurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const noexcept + { return fp_vkCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); } #endif #if (defined(VK_KHR_win32_surface)) - VkBool32 getPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex) const noexcept { + VkBool32 getPhysicalDeviceWin32PresentationSupportKHR(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex) const noexcept + { return fp_vkGetPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex); } #endif #if (defined(VK_KHR_xlib_surface)) - VkResult createXlibSurfaceKHR(const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const noexcept { + VkResult createXlibSurfaceKHR(const VkXlibSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const noexcept + { return fp_vkCreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); } #endif #if (defined(VK_KHR_xlib_surface)) - VkBool32 getPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, Display* dpy, VisualID visualID) const noexcept { + VkBool32 getPhysicalDeviceXlibPresentationSupportKHR(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + Display* dpy, + VisualID visualID) const noexcept + { return fp_vkGetPhysicalDeviceXlibPresentationSupportKHR(physicalDevice, queueFamilyIndex, dpy, visualID); } #endif #if (defined(VK_KHR_xcb_surface)) - VkResult createXcbSurfaceKHR(const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const noexcept { + VkResult createXcbSurfaceKHR(const VkXcbSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const noexcept + { return fp_vkCreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); } #endif #if (defined(VK_KHR_xcb_surface)) - VkBool32 getPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, xcb_connection_t* connection, xcb_visualid_t visual_id) const noexcept { + VkBool32 getPhysicalDeviceXcbPresentationSupportKHR(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + xcb_connection_t* connection, + xcb_visualid_t visual_id) const noexcept + { return fp_vkGetPhysicalDeviceXcbPresentationSupportKHR(physicalDevice, queueFamilyIndex, connection, visual_id); } #endif #if (defined(VK_EXT_directfb_surface)) - VkResult createDirectFBSurfaceEXT(const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const noexcept { + VkResult createDirectFBSurfaceEXT(const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const noexcept + { return fp_vkCreateDirectFBSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); } #endif #if (defined(VK_EXT_directfb_surface)) - VkBool32 getPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, IDirectFB* dfb) const noexcept { + VkBool32 getPhysicalDeviceDirectFBPresentationSupportEXT(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + IDirectFB* dfb) const noexcept + { return fp_vkGetPhysicalDeviceDirectFBPresentationSupportEXT(physicalDevice, queueFamilyIndex, dfb); } #endif #if (defined(VK_FUCHSIA_imagepipe_surface)) - VkResult createImagePipeSurfaceFUCHSIA(const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const noexcept { + VkResult createImagePipeSurfaceFUCHSIA(const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const noexcept + { return fp_vkCreateImagePipeSurfaceFUCHSIA(instance, pCreateInfo, pAllocator, pSurface); } #endif #if (defined(VK_GGP_stream_descriptor_surface)) - VkResult createStreamDescriptorSurfaceGGP(const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const noexcept { + VkResult createStreamDescriptorSurfaceGGP(const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const noexcept + { return fp_vkCreateStreamDescriptorSurfaceGGP(instance, pCreateInfo, pAllocator, pSurface); } #endif #if (defined(VK_QNX_screen_surface)) - VkResult createScreenSurfaceQNX(const VkScreenSurfaceCreateInfoQNX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const noexcept { + VkResult createScreenSurfaceQNX(const VkScreenSurfaceCreateInfoQNX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const noexcept + { return fp_vkCreateScreenSurfaceQNX(instance, pCreateInfo, pAllocator, pSurface); } #endif #if (defined(VK_QNX_screen_surface)) - VkBool32 getPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, struct _screen_window* window) const noexcept { + VkBool32 getPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct _screen_window* window) const noexcept + { return fp_vkGetPhysicalDeviceScreenPresentationSupportQNX(physicalDevice, queueFamilyIndex, window); } #endif #if (defined(VK_EXT_debug_report)) - VkResult createDebugReportCallbackEXT(const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback) const noexcept { + VkResult createDebugReportCallbackEXT(const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugReportCallbackEXT* pCallback) const noexcept + { return fp_vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); } #endif #if (defined(VK_EXT_debug_report)) - void destroyDebugReportCallbackEXT(VkDebugReportCallbackEXT callback, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyDebugReportCallbackEXT(VkDebugReportCallbackEXT callback, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyDebugReportCallbackEXT(instance, callback, pAllocator); } #endif #if (defined(VK_EXT_debug_report)) - void debugReportMessageEXT(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage) const noexcept { + void debugReportMessageEXT(VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage) const noexcept + { fp_vkDebugReportMessageEXT(instance, flags, objectType, object, location, messageCode, pLayerPrefix, pMessage); } #endif #if (defined(VK_NV_external_memory_capabilities)) - VkResult getPhysicalDeviceExternalImageFormatPropertiesNV(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) const noexcept { - return fp_vkGetPhysicalDeviceExternalImageFormatPropertiesNV(physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); + VkResult getPhysicalDeviceExternalImageFormatPropertiesNV( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkExternalMemoryHandleTypeFlagsNV externalHandleType, + VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties) const noexcept + { + return fp_vkGetPhysicalDeviceExternalImageFormatPropertiesNV( + physicalDevice, format, type, tiling, usage, flags, externalHandleType, pExternalImageFormatProperties); } #endif #if (defined(VK_VERSION_1_1)) - void getPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures) const noexcept { + void getPhysicalDeviceFeatures2(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2KHR* pFeatures) const noexcept + { fp_vkGetPhysicalDeviceFeatures2(physicalDevice, pFeatures); } #endif #if (defined(VK_VERSION_1_1)) - void getPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHR* pProperties) const noexcept { + void getPhysicalDeviceProperties2(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2KHR* pProperties) const noexcept + { fp_vkGetPhysicalDeviceProperties2(physicalDevice, pProperties); } #endif #if (defined(VK_VERSION_1_1)) - void getPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR* pFormatProperties) const noexcept { + void getPhysicalDeviceFormatProperties2(VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2KHR* pFormatProperties) const noexcept + { fp_vkGetPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties); } #endif #if (defined(VK_VERSION_1_1)) - VkResult getPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, VkImageFormatProperties2KHR* pImageFormatProperties) const noexcept { + VkResult getPhysicalDeviceImageFormatProperties2(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, + VkImageFormatProperties2KHR* pImageFormatProperties) const noexcept + { return fp_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); } #endif #if (defined(VK_VERSION_1_1)) - void getPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties) const noexcept { + void getPhysicalDeviceQueueFamilyProperties2(VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2KHR* pQueueFamilyProperties) const noexcept + { fp_vkGetPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); } #endif #if (defined(VK_VERSION_1_1)) - void getPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties) const noexcept { + void getPhysicalDeviceMemoryProperties2(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties) const noexcept + { fp_vkGetPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties); } #endif #if (defined(VK_VERSION_1_1)) - void getPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2KHR* pProperties) const noexcept { + void getPhysicalDeviceSparseImageFormatProperties2(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2KHR* pProperties) const noexcept + { fp_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties); } #endif #if (defined(VK_VERSION_1_1)) - void getPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, VkExternalBufferPropertiesKHR* pExternalBufferProperties) const noexcept { + void + getPhysicalDeviceExternalBufferProperties(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, + VkExternalBufferPropertiesKHR* pExternalBufferProperties) const noexcept + { fp_vkGetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); } #endif #if (defined(VK_NV_external_memory_sci_buf)) - VkResult getPhysicalDeviceExternalMemorySciBufPropertiesNV(VkPhysicalDevice physicalDevice, VkExternalMemoryHandleTypeFlagBitsKHR handleType, NvSciBufObj handle, VkMemorySciBufPropertiesNV* pMemorySciBufProperties) const noexcept { - return fp_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV(physicalDevice, handleType, handle, pMemorySciBufProperties); + VkResult getPhysicalDeviceExternalMemorySciBufPropertiesNV( + VkPhysicalDevice physicalDevice, + VkExternalMemoryHandleTypeFlagBitsKHR handleType, + NvSciBufObj handle, + VkMemorySciBufPropertiesNV* pMemorySciBufProperties) const noexcept + { + return fp_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV( + physicalDevice, handleType, handle, pMemorySciBufProperties); } #endif #if (defined(VK_NV_external_memory_sci_buf)) - VkResult getPhysicalDeviceSciBufAttributesNV(VkPhysicalDevice physicalDevice, NvSciBufAttrList pAttributes) const noexcept { + VkResult getPhysicalDeviceSciBufAttributesNV(VkPhysicalDevice physicalDevice, + NvSciBufAttrList pAttributes) const noexcept + { return fp_vkGetPhysicalDeviceSciBufAttributesNV(physicalDevice, pAttributes); } #endif #if (defined(VK_VERSION_1_1)) - void getPhysicalDeviceExternalSemaphoreProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties) const noexcept { - fp_vkGetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); + void getPhysicalDeviceExternalSemaphoreProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties) const noexcept + { + fp_vkGetPhysicalDeviceExternalSemaphoreProperties( + physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); } #endif #if (defined(VK_VERSION_1_1)) - void getPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, VkExternalFencePropertiesKHR* pExternalFenceProperties) const noexcept { + void getPhysicalDeviceExternalFenceProperties(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, + VkExternalFencePropertiesKHR* pExternalFenceProperties) const noexcept + { fp_vkGetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); } #endif #if (defined(VK_NV_external_sci_sync)) || (defined(VK_NV_external_sci_sync2)) - VkResult getPhysicalDeviceSciSyncAttributesNV(VkPhysicalDevice physicalDevice, const VkSciSyncAttributesInfoNV* pSciSyncAttributesInfo, NvSciSyncAttrList pAttributes) const noexcept { + VkResult getPhysicalDeviceSciSyncAttributesNV(VkPhysicalDevice physicalDevice, + const VkSciSyncAttributesInfoNV* pSciSyncAttributesInfo, + NvSciSyncAttrList pAttributes) const noexcept + { return fp_vkGetPhysicalDeviceSciSyncAttributesNV(physicalDevice, pSciSyncAttributesInfo, pAttributes); } #endif #if (defined(VK_EXT_direct_mode_display)) - VkResult releaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) const noexcept { + VkResult releaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) const noexcept + { return fp_vkReleaseDisplayEXT(physicalDevice, display); } #endif #if (defined(VK_EXT_acquire_xlib_display)) - VkResult acquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) const noexcept { + VkResult acquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, VkDisplayKHR display) const noexcept + { return fp_vkAcquireXlibDisplayEXT(physicalDevice, dpy, display); } #endif #if (defined(VK_EXT_acquire_xlib_display)) - VkResult getRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display* dpy, RROutput rrOutput, VkDisplayKHR* pDisplay) const noexcept { + VkResult getRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, + Display* dpy, + RROutput rrOutput, + VkDisplayKHR* pDisplay) const noexcept + { return fp_vkGetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay); } #endif #if (defined(VK_NV_acquire_winrt_display)) - VkResult acquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display) const noexcept { + VkResult acquireWinrtDisplayNV(VkPhysicalDevice physicalDevice, VkDisplayKHR display) const noexcept + { return fp_vkAcquireWinrtDisplayNV(physicalDevice, display); } #endif #if (defined(VK_NV_acquire_winrt_display)) - VkResult getWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay) const noexcept { + VkResult + getWinrtDisplayNV(VkPhysicalDevice physicalDevice, uint32_t deviceRelativeId, VkDisplayKHR* pDisplay) const noexcept + { return fp_vkGetWinrtDisplayNV(physicalDevice, deviceRelativeId, pDisplay); } #endif #if (defined(VK_EXT_display_surface_counter)) - VkResult getPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT* pSurfaceCapabilities) const noexcept { + VkResult getPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities) const noexcept + { return fp_vkGetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); } #endif #if (defined(VK_VERSION_1_1)) - VkResult enumeratePhysicalDeviceGroups(uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHR* pPhysicalDeviceGroupProperties) const noexcept { + VkResult + enumeratePhysicalDeviceGroups(uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupPropertiesKHR* pPhysicalDeviceGroupProperties) const noexcept + { return fp_vkEnumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); } #endif #if (defined(VK_KHR_swapchain)) || (defined(VK_KHR_device_group)) - VkResult getPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pRectCount, VkRect2D* pRects) const noexcept { + VkResult getPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pRectCount, + VkRect2D* pRects) const noexcept + { return fp_vkGetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); } #endif #if (defined(VK_MVK_ios_surface)) - VkResult createIOSSurfaceMVK(const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const noexcept { + VkResult createIOSSurfaceMVK(const VkIOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const noexcept + { return fp_vkCreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); } #endif #if (defined(VK_MVK_macos_surface)) - VkResult createMacOSSurfaceMVK(const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const noexcept { + VkResult createMacOSSurfaceMVK(const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const noexcept + { return fp_vkCreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); } #endif #if (defined(VK_EXT_metal_surface)) - VkResult createMetalSurfaceEXT(const VkMetalSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const noexcept { + VkResult createMetalSurfaceEXT(const VkMetalSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const noexcept + { return fp_vkCreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); } #endif #if (defined(VK_EXT_sample_locations)) - void getPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, VkSampleCountFlagBits samples, VkMultisamplePropertiesEXT* pMultisampleProperties) const noexcept { + void getPhysicalDeviceMultisamplePropertiesEXT(VkPhysicalDevice physicalDevice, + VkSampleCountFlagBits samples, + VkMultisamplePropertiesEXT* pMultisampleProperties) const noexcept + { fp_vkGetPhysicalDeviceMultisamplePropertiesEXT(physicalDevice, samples, pMultisampleProperties); } #endif #if (defined(VK_KHR_get_surface_capabilities2)) - VkResult getPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) const noexcept { + VkResult getPhysicalDeviceSurfaceCapabilities2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities) const noexcept + { return fp_vkGetPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities); } #endif #if (defined(VK_KHR_get_surface_capabilities2)) - VkResult getPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) const noexcept { - return fp_vkGetPhysicalDeviceSurfaceFormats2KHR(physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); + VkResult getPhysicalDeviceSurfaceFormats2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats) const noexcept + { + return fp_vkGetPhysicalDeviceSurfaceFormats2KHR( + physicalDevice, pSurfaceInfo, pSurfaceFormatCount, pSurfaceFormats); } #endif #if (defined(VK_KHR_get_display_properties2)) - VkResult getPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayProperties2KHR* pProperties) const noexcept { + VkResult getPhysicalDeviceDisplayProperties2KHR(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayProperties2KHR* pProperties) const noexcept + { return fp_vkGetPhysicalDeviceDisplayProperties2KHR(physicalDevice, pPropertyCount, pProperties); } #endif #if (defined(VK_KHR_get_display_properties2)) - VkResult getPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkDisplayPlaneProperties2KHR* pProperties) const noexcept { + VkResult getPhysicalDeviceDisplayPlaneProperties2KHR(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlaneProperties2KHR* pProperties) const noexcept + { return fp_vkGetPhysicalDeviceDisplayPlaneProperties2KHR(physicalDevice, pPropertyCount, pProperties); } #endif #if (defined(VK_KHR_get_display_properties2)) - VkResult getDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, VkDisplayKHR display, uint32_t* pPropertyCount, VkDisplayModeProperties2KHR* pProperties) const noexcept { + VkResult getDisplayModeProperties2KHR(VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModeProperties2KHR* pProperties) const noexcept + { return fp_vkGetDisplayModeProperties2KHR(physicalDevice, display, pPropertyCount, pProperties); } #endif #if (defined(VK_KHR_get_display_properties2)) - VkResult getDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, VkDisplayPlaneCapabilities2KHR* pCapabilities) const noexcept { + VkResult getDisplayPlaneCapabilities2KHR(VkPhysicalDevice physicalDevice, + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, + VkDisplayPlaneCapabilities2KHR* pCapabilities) const noexcept + { return fp_vkGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities); } #endif #if (defined(VK_KHR_calibrated_timestamps)) - VkResult getPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains) const noexcept { + VkResult getPhysicalDeviceCalibrateableTimeDomainsKHR(VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainEXT* pTimeDomains) const noexcept + { return fp_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR(physicalDevice, pTimeDomainCount, pTimeDomains); } #endif #if (defined(VK_EXT_debug_utils)) - VkResult createDebugUtilsMessengerEXT(const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugUtilsMessengerEXT* pMessenger) const noexcept { + VkResult createDebugUtilsMessengerEXT(const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pMessenger) const noexcept + { return fp_vkCreateDebugUtilsMessengerEXT(instance, pCreateInfo, pAllocator, pMessenger); } #endif #if (defined(VK_EXT_debug_utils)) - void destroyDebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT messenger, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyDebugUtilsMessengerEXT(VkDebugUtilsMessengerEXT messenger, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); } #endif #if (defined(VK_EXT_debug_utils)) - void submitDebugUtilsMessageEXT(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, VkDebugUtilsMessageTypeFlagsEXT messageTypes, const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) const noexcept { + void submitDebugUtilsMessageEXT(VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) const noexcept + { fp_vkSubmitDebugUtilsMessageEXT(instance, messageSeverity, messageTypes, pCallbackData); } #endif #if (defined(VK_NV_cooperative_matrix)) - VkResult getPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesNV* pProperties) const noexcept { + VkResult getPhysicalDeviceCooperativeMatrixPropertiesNV(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeMatrixPropertiesNV* pProperties) const noexcept + { return fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV(physicalDevice, pPropertyCount, pProperties); } #endif #if (defined(VK_EXT_full_screen_exclusive)) - VkResult getPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) const noexcept { - return fp_vkGetPhysicalDeviceSurfacePresentModes2EXT(physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes); + VkResult getPhysicalDeviceSurfacePresentModes2EXT(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes) const noexcept + { + return fp_vkGetPhysicalDeviceSurfacePresentModes2EXT( + physicalDevice, pSurfaceInfo, pPresentModeCount, pPresentModes); } #endif #if (defined(VK_KHR_performance_query)) - VkResult enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, uint32_t* pCounterCount, VkPerformanceCounterKHR* pCounters, VkPerformanceCounterDescriptionKHR* pCounterDescriptions) const noexcept { - return fp_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); + VkResult enumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t* pCounterCount, + VkPerformanceCounterKHR* pCounters, + VkPerformanceCounterDescriptionKHR* pCounterDescriptions) const noexcept + { + return fp_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + physicalDevice, queueFamilyIndex, pCounterCount, pCounters, pCounterDescriptions); } #endif #if (defined(VK_KHR_performance_query)) - void getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(VkPhysicalDevice physicalDevice, const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, uint32_t* pNumPasses) const noexcept { - fp_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(physicalDevice, pPerformanceQueryCreateInfo, pNumPasses); + void getPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( + VkPhysicalDevice physicalDevice, + const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, + uint32_t* pNumPasses) const noexcept + { + fp_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( + physicalDevice, pPerformanceQueryCreateInfo, pNumPasses); } #endif #if (defined(VK_EXT_headless_surface)) - VkResult createHeadlessSurfaceEXT(const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const noexcept { + VkResult createHeadlessSurfaceEXT(const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) const noexcept + { return fp_vkCreateHeadlessSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); } #endif #if (defined(VK_NV_coverage_reduction_mode)) - VkResult getPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(VkPhysicalDevice physicalDevice, uint32_t* pCombinationCount, VkFramebufferMixedSamplesCombinationNV* pCombinations) const noexcept { - return fp_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(physicalDevice, pCombinationCount, pCombinations); + VkResult getPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( + VkPhysicalDevice physicalDevice, + uint32_t* pCombinationCount, + VkFramebufferMixedSamplesCombinationNV* pCombinations) const noexcept + { + return fp_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( + physicalDevice, pCombinationCount, pCombinations); } #endif #if (defined(VK_VERSION_1_3)) - VkResult getPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolPropertiesEXT* pToolProperties) const noexcept { + VkResult getPhysicalDeviceToolProperties(VkPhysicalDevice physicalDevice, + uint32_t* pToolCount, + VkPhysicalDeviceToolPropertiesEXT* pToolProperties) const noexcept + { return fp_vkGetPhysicalDeviceToolProperties(physicalDevice, pToolCount, pToolProperties); } #endif #if (defined(VK_KHR_object_refresh)) - VkResult getPhysicalDeviceRefreshableObjectTypesKHR(VkPhysicalDevice physicalDevice, uint32_t* pRefreshableObjectTypeCount, VkObjectType* pRefreshableObjectTypes) const noexcept { - return fp_vkGetPhysicalDeviceRefreshableObjectTypesKHR(physicalDevice, pRefreshableObjectTypeCount, pRefreshableObjectTypes); + VkResult getPhysicalDeviceRefreshableObjectTypesKHR(VkPhysicalDevice physicalDevice, + uint32_t* pRefreshableObjectTypeCount, + VkObjectType* pRefreshableObjectTypes) const noexcept + { + return fp_vkGetPhysicalDeviceRefreshableObjectTypesKHR( + physicalDevice, pRefreshableObjectTypeCount, pRefreshableObjectTypes); } #endif #if (defined(VK_KHR_fragment_shading_rate)) - VkResult getPhysicalDeviceFragmentShadingRatesKHR(VkPhysicalDevice physicalDevice, uint32_t* pFragmentShadingRateCount, VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) const noexcept { - return fp_vkGetPhysicalDeviceFragmentShadingRatesKHR(physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates); + VkResult getPhysicalDeviceFragmentShadingRatesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pFragmentShadingRateCount, + VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) const noexcept + { + return fp_vkGetPhysicalDeviceFragmentShadingRatesKHR( + physicalDevice, pFragmentShadingRateCount, pFragmentShadingRates); } #endif #if (defined(VK_KHR_video_queue)) - VkResult getPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, const VkVideoProfileInfoKHR* pVideoProfile, VkVideoCapabilitiesKHR* pCapabilities) const noexcept { + VkResult getPhysicalDeviceVideoCapabilitiesKHR(VkPhysicalDevice physicalDevice, + const VkVideoProfileInfoKHR* pVideoProfile, + VkVideoCapabilitiesKHR* pCapabilities) const noexcept + { return fp_vkGetPhysicalDeviceVideoCapabilitiesKHR(physicalDevice, pVideoProfile, pCapabilities); } #endif #if (defined(VK_KHR_video_queue)) - VkResult getPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, uint32_t* pVideoFormatPropertyCount, VkVideoFormatPropertiesKHR* pVideoFormatProperties) const noexcept { - return fp_vkGetPhysicalDeviceVideoFormatPropertiesKHR(physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties); + VkResult + getPhysicalDeviceVideoFormatPropertiesKHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, + uint32_t* pVideoFormatPropertyCount, + VkVideoFormatPropertiesKHR* pVideoFormatProperties) const noexcept + { + return fp_vkGetPhysicalDeviceVideoFormatPropertiesKHR( + physicalDevice, pVideoFormatInfo, pVideoFormatPropertyCount, pVideoFormatProperties); } #endif #if (defined(VK_KHR_video_encode_queue)) - VkResult getPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) const noexcept { - return fp_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR(physicalDevice, pQualityLevelInfo, pQualityLevelProperties); + VkResult getPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, + VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) const noexcept + { + return fp_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + physicalDevice, pQualityLevelInfo, pQualityLevelProperties); } #endif #if (defined(VK_EXT_acquire_drm_display)) - VkResult acquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) const noexcept { + VkResult acquireDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, VkDisplayKHR display) const noexcept + { return fp_vkAcquireDrmDisplayEXT(physicalDevice, drmFd, display); } #endif #if (defined(VK_EXT_acquire_drm_display)) - VkResult getDrmDisplayEXT(VkPhysicalDevice physicalDevice, int32_t drmFd, uint32_t connectorId, VkDisplayKHR* display) const noexcept { + VkResult getDrmDisplayEXT(VkPhysicalDevice physicalDevice, + int32_t drmFd, + uint32_t connectorId, + VkDisplayKHR* display) const noexcept + { return fp_vkGetDrmDisplayEXT(physicalDevice, drmFd, connectorId, display); } #endif #if (defined(VK_NV_optical_flow)) - VkResult getPhysicalDeviceOpticalFlowImageFormatsNV(VkPhysicalDevice physicalDevice, const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, uint32_t* pFormatCount, VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) const noexcept { - return fp_vkGetPhysicalDeviceOpticalFlowImageFormatsNV(physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties); + VkResult getPhysicalDeviceOpticalFlowImageFormatsNV( + VkPhysicalDevice physicalDevice, + const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) const noexcept + { + return fp_vkGetPhysicalDeviceOpticalFlowImageFormatsNV( + physicalDevice, pOpticalFlowImageFormatInfo, pFormatCount, pImageFormatProperties); } #endif #if (defined(VK_KHR_cooperative_matrix)) - VkResult getPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties) const noexcept { + VkResult + getPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeMatrixPropertiesKHR* pProperties) const noexcept + { return fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(physicalDevice, pPropertyCount, pProperties); } #endif #if (defined(VK_KHR_get_physical_device_properties2)) - void getPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures) const noexcept { + void getPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2KHR* pFeatures) const noexcept + { fp_vkGetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); } #endif #if (defined(VK_KHR_get_physical_device_properties2)) - void getPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHR* pProperties) const noexcept { + void getPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2KHR* pProperties) const noexcept + { fp_vkGetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); } #endif #if (defined(VK_KHR_get_physical_device_properties2)) - void getPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2KHR* pFormatProperties) const noexcept { + void getPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2KHR* pFormatProperties) const noexcept + { fp_vkGetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); } #endif #if (defined(VK_KHR_get_physical_device_properties2)) - VkResult getPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, VkImageFormatProperties2KHR* pImageFormatProperties) const noexcept { - return fp_vkGetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); + VkResult + getPhysicalDeviceImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, + VkImageFormatProperties2KHR* pImageFormatProperties) const noexcept + { + return fp_vkGetPhysicalDeviceImageFormatProperties2KHR( + physicalDevice, pImageFormatInfo, pImageFormatProperties); } #endif #if (defined(VK_KHR_get_physical_device_properties2)) - void getPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR* pQueueFamilyProperties) const noexcept { - fp_vkGetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + void getPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2KHR* pQueueFamilyProperties) const noexcept + { + fp_vkGetPhysicalDeviceQueueFamilyProperties2KHR( + physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); } #endif #if (defined(VK_KHR_get_physical_device_properties2)) - void getPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties) const noexcept { + void getPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2KHR* pMemoryProperties) const noexcept + { fp_vkGetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); } #endif #if (defined(VK_KHR_get_physical_device_properties2)) - void getPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, uint32_t* pPropertyCount, VkSparseImageFormatProperties2KHR* pProperties) const noexcept { + void getPhysicalDeviceSparseImageFormatProperties2KHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2KHR* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2KHR* pProperties) const noexcept + { fp_vkGetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); } #endif #if (defined(VK_KHR_external_memory_capabilities)) - void getPhysicalDeviceExternalBufferPropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, VkExternalBufferPropertiesKHR* pExternalBufferProperties) const noexcept { - fp_vkGetPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); + void getPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, + VkExternalBufferPropertiesKHR* pExternalBufferProperties) const noexcept + { + fp_vkGetPhysicalDeviceExternalBufferPropertiesKHR( + physicalDevice, pExternalBufferInfo, pExternalBufferProperties); } #endif #if (defined(VK_KHR_external_semaphore_capabilities)) - void getPhysicalDeviceExternalSemaphorePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties) const noexcept { - fp_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); + void getPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfoKHR* pExternalSemaphoreInfo, + VkExternalSemaphorePropertiesKHR* pExternalSemaphoreProperties) const noexcept + { + fp_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR( + physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); } #endif #if (defined(VK_KHR_external_fence_capabilities)) - void getPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, VkExternalFencePropertiesKHR* pExternalFenceProperties) const noexcept { + void + getPhysicalDeviceExternalFencePropertiesKHR(VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfoKHR* pExternalFenceInfo, + VkExternalFencePropertiesKHR* pExternalFenceProperties) const noexcept + { fp_vkGetPhysicalDeviceExternalFencePropertiesKHR(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); } #endif #if (defined(VK_KHR_device_group_creation)) - VkResult enumeratePhysicalDeviceGroupsKHR(uint32_t* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupPropertiesKHR* pPhysicalDeviceGroupProperties) const noexcept { - return fp_vkEnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); + VkResult + enumeratePhysicalDeviceGroupsKHR(uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupPropertiesKHR* pPhysicalDeviceGroupProperties) const noexcept + { + return fp_vkEnumeratePhysicalDeviceGroupsKHR( + instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); } #endif #if (defined(VK_EXT_calibrated_timestamps)) - VkResult getPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains) const noexcept { + VkResult getPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainEXT* pTimeDomains) const noexcept + { return fp_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains); } #endif #if (defined(VK_EXT_tooling_info)) - VkResult getPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, uint32_t* pToolCount, VkPhysicalDeviceToolPropertiesEXT* pToolProperties) const noexcept { + VkResult getPhysicalDeviceToolPropertiesEXT(VkPhysicalDevice physicalDevice, + uint32_t* pToolCount, + VkPhysicalDeviceToolPropertiesEXT* pToolProperties) const noexcept + { return fp_vkGetPhysicalDeviceToolPropertiesEXT(physicalDevice, pToolCount, pToolProperties); } #endif - PFN_vkDestroyInstance fp_vkDestroyInstance = nullptr; - PFN_vkEnumeratePhysicalDevices fp_vkEnumeratePhysicalDevices = nullptr; - PFN_vkGetInstanceProcAddr fp_vkGetInstanceProcAddr = nullptr; - PFN_vkGetPhysicalDeviceProperties fp_vkGetPhysicalDeviceProperties = nullptr; - PFN_vkGetPhysicalDeviceQueueFamilyProperties fp_vkGetPhysicalDeviceQueueFamilyProperties = nullptr; - PFN_vkGetPhysicalDeviceMemoryProperties fp_vkGetPhysicalDeviceMemoryProperties = nullptr; - PFN_vkGetPhysicalDeviceFeatures fp_vkGetPhysicalDeviceFeatures = nullptr; - PFN_vkGetPhysicalDeviceFormatProperties fp_vkGetPhysicalDeviceFormatProperties = nullptr; - PFN_vkGetPhysicalDeviceImageFormatProperties fp_vkGetPhysicalDeviceImageFormatProperties = nullptr; - PFN_vkEnumerateDeviceLayerProperties fp_vkEnumerateDeviceLayerProperties = nullptr; - PFN_vkEnumerateDeviceExtensionProperties fp_vkEnumerateDeviceExtensionProperties = nullptr; + PFN_vkDestroyInstance fp_vkDestroyInstance = nullptr; + PFN_vkEnumeratePhysicalDevices fp_vkEnumeratePhysicalDevices = nullptr; + PFN_vkGetInstanceProcAddr fp_vkGetInstanceProcAddr = nullptr; + PFN_vkGetPhysicalDeviceProperties fp_vkGetPhysicalDeviceProperties = nullptr; + PFN_vkGetPhysicalDeviceQueueFamilyProperties fp_vkGetPhysicalDeviceQueueFamilyProperties = nullptr; + PFN_vkGetPhysicalDeviceMemoryProperties fp_vkGetPhysicalDeviceMemoryProperties = nullptr; + PFN_vkGetPhysicalDeviceFeatures fp_vkGetPhysicalDeviceFeatures = nullptr; + PFN_vkGetPhysicalDeviceFormatProperties fp_vkGetPhysicalDeviceFormatProperties = nullptr; + PFN_vkGetPhysicalDeviceImageFormatProperties fp_vkGetPhysicalDeviceImageFormatProperties = nullptr; + PFN_vkEnumerateDeviceLayerProperties fp_vkEnumerateDeviceLayerProperties = nullptr; + PFN_vkEnumerateDeviceExtensionProperties fp_vkEnumerateDeviceExtensionProperties = nullptr; PFN_vkGetPhysicalDeviceSparseImageFormatProperties fp_vkGetPhysicalDeviceSparseImageFormatProperties = nullptr; #if (defined(VK_KHR_android_surface)) PFN_vkCreateAndroidSurfaceKHR fp_vkCreateAndroidSurfaceKHR = nullptr; #else - void * fp_vkCreateAndroidSurfaceKHR{}; + void* fp_vkCreateAndroidSurfaceKHR{}; #endif #if (defined(VK_KHR_display)) PFN_vkGetPhysicalDeviceDisplayPropertiesKHR fp_vkGetPhysicalDeviceDisplayPropertiesKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceDisplayPropertiesKHR{}; + void* fp_vkGetPhysicalDeviceDisplayPropertiesKHR{}; #endif #if (defined(VK_KHR_display)) PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR fp_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceDisplayPlanePropertiesKHR{}; + void* fp_vkGetPhysicalDeviceDisplayPlanePropertiesKHR{}; #endif #if (defined(VK_KHR_display)) PFN_vkGetDisplayPlaneSupportedDisplaysKHR fp_vkGetDisplayPlaneSupportedDisplaysKHR = nullptr; #else - void * fp_vkGetDisplayPlaneSupportedDisplaysKHR{}; + void* fp_vkGetDisplayPlaneSupportedDisplaysKHR{}; #endif #if (defined(VK_KHR_display)) PFN_vkGetDisplayModePropertiesKHR fp_vkGetDisplayModePropertiesKHR = nullptr; #else - void * fp_vkGetDisplayModePropertiesKHR{}; + void* fp_vkGetDisplayModePropertiesKHR{}; #endif #if (defined(VK_KHR_display)) PFN_vkCreateDisplayModeKHR fp_vkCreateDisplayModeKHR = nullptr; #else - void * fp_vkCreateDisplayModeKHR{}; + void* fp_vkCreateDisplayModeKHR{}; #endif #if (defined(VK_KHR_display)) PFN_vkGetDisplayPlaneCapabilitiesKHR fp_vkGetDisplayPlaneCapabilitiesKHR = nullptr; #else - void * fp_vkGetDisplayPlaneCapabilitiesKHR{}; + void* fp_vkGetDisplayPlaneCapabilitiesKHR{}; #endif #if (defined(VK_KHR_display)) PFN_vkCreateDisplayPlaneSurfaceKHR fp_vkCreateDisplayPlaneSurfaceKHR = nullptr; #else - void * fp_vkCreateDisplayPlaneSurfaceKHR{}; + void* fp_vkCreateDisplayPlaneSurfaceKHR{}; #endif #if (defined(VK_KHR_surface)) PFN_vkDestroySurfaceKHR fp_vkDestroySurfaceKHR = nullptr; #else - void * fp_vkDestroySurfaceKHR{}; + void* fp_vkDestroySurfaceKHR{}; #endif #if (defined(VK_KHR_surface)) PFN_vkGetPhysicalDeviceSurfaceSupportKHR fp_vkGetPhysicalDeviceSurfaceSupportKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceSurfaceSupportKHR{}; + void* fp_vkGetPhysicalDeviceSurfaceSupportKHR{}; #endif #if (defined(VK_KHR_surface)) PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR fp_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceSurfaceCapabilitiesKHR{}; + void* fp_vkGetPhysicalDeviceSurfaceCapabilitiesKHR{}; #endif #if (defined(VK_KHR_surface)) PFN_vkGetPhysicalDeviceSurfaceFormatsKHR fp_vkGetPhysicalDeviceSurfaceFormatsKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceSurfaceFormatsKHR{}; + void* fp_vkGetPhysicalDeviceSurfaceFormatsKHR{}; #endif #if (defined(VK_KHR_surface)) PFN_vkGetPhysicalDeviceSurfacePresentModesKHR fp_vkGetPhysicalDeviceSurfacePresentModesKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceSurfacePresentModesKHR{}; + void* fp_vkGetPhysicalDeviceSurfacePresentModesKHR{}; #endif #if (defined(VK_NN_vi_surface)) PFN_vkCreateViSurfaceNN fp_vkCreateViSurfaceNN = nullptr; #else - void * fp_vkCreateViSurfaceNN{}; + void* fp_vkCreateViSurfaceNN{}; #endif #if (defined(VK_KHR_wayland_surface)) PFN_vkCreateWaylandSurfaceKHR fp_vkCreateWaylandSurfaceKHR = nullptr; #else - void * fp_vkCreateWaylandSurfaceKHR{}; + void* fp_vkCreateWaylandSurfaceKHR{}; #endif #if (defined(VK_KHR_wayland_surface)) PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR fp_vkGetPhysicalDeviceWaylandPresentationSupportKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceWaylandPresentationSupportKHR{}; + void* fp_vkGetPhysicalDeviceWaylandPresentationSupportKHR{}; #endif #if (defined(VK_KHR_win32_surface)) PFN_vkCreateWin32SurfaceKHR fp_vkCreateWin32SurfaceKHR = nullptr; #else - void * fp_vkCreateWin32SurfaceKHR{}; + void* fp_vkCreateWin32SurfaceKHR{}; #endif #if (defined(VK_KHR_win32_surface)) PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR fp_vkGetPhysicalDeviceWin32PresentationSupportKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceWin32PresentationSupportKHR{}; + void* fp_vkGetPhysicalDeviceWin32PresentationSupportKHR{}; #endif #if (defined(VK_KHR_xlib_surface)) PFN_vkCreateXlibSurfaceKHR fp_vkCreateXlibSurfaceKHR = nullptr; #else - void * fp_vkCreateXlibSurfaceKHR{}; + void* fp_vkCreateXlibSurfaceKHR{}; #endif #if (defined(VK_KHR_xlib_surface)) PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR fp_vkGetPhysicalDeviceXlibPresentationSupportKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceXlibPresentationSupportKHR{}; + void* fp_vkGetPhysicalDeviceXlibPresentationSupportKHR{}; #endif #if (defined(VK_KHR_xcb_surface)) PFN_vkCreateXcbSurfaceKHR fp_vkCreateXcbSurfaceKHR = nullptr; #else - void * fp_vkCreateXcbSurfaceKHR{}; + void* fp_vkCreateXcbSurfaceKHR{}; #endif #if (defined(VK_KHR_xcb_surface)) PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR fp_vkGetPhysicalDeviceXcbPresentationSupportKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceXcbPresentationSupportKHR{}; + void* fp_vkGetPhysicalDeviceXcbPresentationSupportKHR{}; #endif #if (defined(VK_EXT_directfb_surface)) PFN_vkCreateDirectFBSurfaceEXT fp_vkCreateDirectFBSurfaceEXT = nullptr; #else - void * fp_vkCreateDirectFBSurfaceEXT{}; + void* fp_vkCreateDirectFBSurfaceEXT{}; #endif #if (defined(VK_EXT_directfb_surface)) - PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT fp_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = nullptr; + PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT fp_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = + nullptr; #else - void * fp_vkGetPhysicalDeviceDirectFBPresentationSupportEXT{}; + void* fp_vkGetPhysicalDeviceDirectFBPresentationSupportEXT{}; #endif #if (defined(VK_FUCHSIA_imagepipe_surface)) PFN_vkCreateImagePipeSurfaceFUCHSIA fp_vkCreateImagePipeSurfaceFUCHSIA = nullptr; #else - void * fp_vkCreateImagePipeSurfaceFUCHSIA{}; + void* fp_vkCreateImagePipeSurfaceFUCHSIA{}; #endif #if (defined(VK_GGP_stream_descriptor_surface)) PFN_vkCreateStreamDescriptorSurfaceGGP fp_vkCreateStreamDescriptorSurfaceGGP = nullptr; #else - void * fp_vkCreateStreamDescriptorSurfaceGGP{}; + void* fp_vkCreateStreamDescriptorSurfaceGGP{}; #endif #if (defined(VK_QNX_screen_surface)) PFN_vkCreateScreenSurfaceQNX fp_vkCreateScreenSurfaceQNX = nullptr; #else - void * fp_vkCreateScreenSurfaceQNX{}; + void* fp_vkCreateScreenSurfaceQNX{}; #endif #if (defined(VK_QNX_screen_surface)) PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX fp_vkGetPhysicalDeviceScreenPresentationSupportQNX = nullptr; #else - void * fp_vkGetPhysicalDeviceScreenPresentationSupportQNX{}; + void* fp_vkGetPhysicalDeviceScreenPresentationSupportQNX{}; #endif #if (defined(VK_EXT_debug_report)) PFN_vkCreateDebugReportCallbackEXT fp_vkCreateDebugReportCallbackEXT = nullptr; #else - void * fp_vkCreateDebugReportCallbackEXT{}; + void* fp_vkCreateDebugReportCallbackEXT{}; #endif #if (defined(VK_EXT_debug_report)) PFN_vkDestroyDebugReportCallbackEXT fp_vkDestroyDebugReportCallbackEXT = nullptr; #else - void * fp_vkDestroyDebugReportCallbackEXT{}; + void* fp_vkDestroyDebugReportCallbackEXT{}; #endif #if (defined(VK_EXT_debug_report)) PFN_vkDebugReportMessageEXT fp_vkDebugReportMessageEXT = nullptr; #else - void * fp_vkDebugReportMessageEXT{}; + void* fp_vkDebugReportMessageEXT{}; #endif #if (defined(VK_NV_external_memory_capabilities)) - PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV fp_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = nullptr; + PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV fp_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = + nullptr; #else - void * fp_vkGetPhysicalDeviceExternalImageFormatPropertiesNV{}; + void* fp_vkGetPhysicalDeviceExternalImageFormatPropertiesNV{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkGetPhysicalDeviceFeatures2 fp_vkGetPhysicalDeviceFeatures2 = nullptr; #else - void * fp_vkGetPhysicalDeviceFeatures2{}; + void* fp_vkGetPhysicalDeviceFeatures2{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkGetPhysicalDeviceProperties2 fp_vkGetPhysicalDeviceProperties2 = nullptr; #else - void * fp_vkGetPhysicalDeviceProperties2{}; + void* fp_vkGetPhysicalDeviceProperties2{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkGetPhysicalDeviceFormatProperties2 fp_vkGetPhysicalDeviceFormatProperties2 = nullptr; #else - void * fp_vkGetPhysicalDeviceFormatProperties2{}; + void* fp_vkGetPhysicalDeviceFormatProperties2{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkGetPhysicalDeviceImageFormatProperties2 fp_vkGetPhysicalDeviceImageFormatProperties2 = nullptr; #else - void * fp_vkGetPhysicalDeviceImageFormatProperties2{}; + void* fp_vkGetPhysicalDeviceImageFormatProperties2{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkGetPhysicalDeviceQueueFamilyProperties2 fp_vkGetPhysicalDeviceQueueFamilyProperties2 = nullptr; #else - void * fp_vkGetPhysicalDeviceQueueFamilyProperties2{}; + void* fp_vkGetPhysicalDeviceQueueFamilyProperties2{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkGetPhysicalDeviceMemoryProperties2 fp_vkGetPhysicalDeviceMemoryProperties2 = nullptr; #else - void * fp_vkGetPhysicalDeviceMemoryProperties2{}; + void* fp_vkGetPhysicalDeviceMemoryProperties2{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 fp_vkGetPhysicalDeviceSparseImageFormatProperties2 = nullptr; #else - void * fp_vkGetPhysicalDeviceSparseImageFormatProperties2{}; + void* fp_vkGetPhysicalDeviceSparseImageFormatProperties2{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkGetPhysicalDeviceExternalBufferProperties fp_vkGetPhysicalDeviceExternalBufferProperties = nullptr; #else - void * fp_vkGetPhysicalDeviceExternalBufferProperties{}; + void* fp_vkGetPhysicalDeviceExternalBufferProperties{}; #endif #if (defined(VK_NV_external_memory_sci_buf)) - PFN_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV fp_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV = nullptr; + PFN_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV fp_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV = + nullptr; #else - void * fp_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV{}; + void* fp_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV{}; #endif #if (defined(VK_NV_external_memory_sci_buf)) PFN_vkGetPhysicalDeviceSciBufAttributesNV fp_vkGetPhysicalDeviceSciBufAttributesNV = nullptr; #else - void * fp_vkGetPhysicalDeviceSciBufAttributesNV{}; + void* fp_vkGetPhysicalDeviceSciBufAttributesNV{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkGetPhysicalDeviceExternalSemaphoreProperties fp_vkGetPhysicalDeviceExternalSemaphoreProperties = nullptr; #else - void * fp_vkGetPhysicalDeviceExternalSemaphoreProperties{}; + void* fp_vkGetPhysicalDeviceExternalSemaphoreProperties{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkGetPhysicalDeviceExternalFenceProperties fp_vkGetPhysicalDeviceExternalFenceProperties = nullptr; #else - void * fp_vkGetPhysicalDeviceExternalFenceProperties{}; + void* fp_vkGetPhysicalDeviceExternalFenceProperties{}; #endif #if (defined(VK_NV_external_sci_sync)) || (defined(VK_NV_external_sci_sync2)) PFN_vkGetPhysicalDeviceSciSyncAttributesNV fp_vkGetPhysicalDeviceSciSyncAttributesNV = nullptr; #else - void * fp_vkGetPhysicalDeviceSciSyncAttributesNV{}; + void* fp_vkGetPhysicalDeviceSciSyncAttributesNV{}; #endif #if (defined(VK_EXT_direct_mode_display)) PFN_vkReleaseDisplayEXT fp_vkReleaseDisplayEXT = nullptr; #else - void * fp_vkReleaseDisplayEXT{}; + void* fp_vkReleaseDisplayEXT{}; #endif #if (defined(VK_EXT_acquire_xlib_display)) PFN_vkAcquireXlibDisplayEXT fp_vkAcquireXlibDisplayEXT = nullptr; #else - void * fp_vkAcquireXlibDisplayEXT{}; + void* fp_vkAcquireXlibDisplayEXT{}; #endif #if (defined(VK_EXT_acquire_xlib_display)) PFN_vkGetRandROutputDisplayEXT fp_vkGetRandROutputDisplayEXT = nullptr; #else - void * fp_vkGetRandROutputDisplayEXT{}; + void* fp_vkGetRandROutputDisplayEXT{}; #endif #if (defined(VK_NV_acquire_winrt_display)) PFN_vkAcquireWinrtDisplayNV fp_vkAcquireWinrtDisplayNV = nullptr; #else - void * fp_vkAcquireWinrtDisplayNV{}; + void* fp_vkAcquireWinrtDisplayNV{}; #endif #if (defined(VK_NV_acquire_winrt_display)) PFN_vkGetWinrtDisplayNV fp_vkGetWinrtDisplayNV = nullptr; #else - void * fp_vkGetWinrtDisplayNV{}; + void* fp_vkGetWinrtDisplayNV{}; #endif #if (defined(VK_EXT_display_surface_counter)) PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT fp_vkGetPhysicalDeviceSurfaceCapabilities2EXT = nullptr; #else - void * fp_vkGetPhysicalDeviceSurfaceCapabilities2EXT{}; + void* fp_vkGetPhysicalDeviceSurfaceCapabilities2EXT{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkEnumeratePhysicalDeviceGroups fp_vkEnumeratePhysicalDeviceGroups = nullptr; #else - void * fp_vkEnumeratePhysicalDeviceGroups{}; + void* fp_vkEnumeratePhysicalDeviceGroups{}; #endif #if (defined(VK_KHR_swapchain)) || (defined(VK_KHR_device_group)) PFN_vkGetPhysicalDevicePresentRectanglesKHR fp_vkGetPhysicalDevicePresentRectanglesKHR = nullptr; #else - void * fp_vkGetPhysicalDevicePresentRectanglesKHR{}; + void* fp_vkGetPhysicalDevicePresentRectanglesKHR{}; #endif #if (defined(VK_MVK_ios_surface)) PFN_vkCreateIOSSurfaceMVK fp_vkCreateIOSSurfaceMVK = nullptr; #else - void * fp_vkCreateIOSSurfaceMVK{}; + void* fp_vkCreateIOSSurfaceMVK{}; #endif #if (defined(VK_MVK_macos_surface)) PFN_vkCreateMacOSSurfaceMVK fp_vkCreateMacOSSurfaceMVK = nullptr; #else - void * fp_vkCreateMacOSSurfaceMVK{}; + void* fp_vkCreateMacOSSurfaceMVK{}; #endif #if (defined(VK_EXT_metal_surface)) PFN_vkCreateMetalSurfaceEXT fp_vkCreateMetalSurfaceEXT = nullptr; #else - void * fp_vkCreateMetalSurfaceEXT{}; + void* fp_vkCreateMetalSurfaceEXT{}; #endif #if (defined(VK_EXT_sample_locations)) PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT fp_vkGetPhysicalDeviceMultisamplePropertiesEXT = nullptr; #else - void * fp_vkGetPhysicalDeviceMultisamplePropertiesEXT{}; + void* fp_vkGetPhysicalDeviceMultisamplePropertiesEXT{}; #endif #if (defined(VK_KHR_get_surface_capabilities2)) PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR fp_vkGetPhysicalDeviceSurfaceCapabilities2KHR = nullptr; #else - void * fp_vkGetPhysicalDeviceSurfaceCapabilities2KHR{}; + void* fp_vkGetPhysicalDeviceSurfaceCapabilities2KHR{}; #endif #if (defined(VK_KHR_get_surface_capabilities2)) PFN_vkGetPhysicalDeviceSurfaceFormats2KHR fp_vkGetPhysicalDeviceSurfaceFormats2KHR = nullptr; #else - void * fp_vkGetPhysicalDeviceSurfaceFormats2KHR{}; + void* fp_vkGetPhysicalDeviceSurfaceFormats2KHR{}; #endif #if (defined(VK_KHR_get_display_properties2)) PFN_vkGetPhysicalDeviceDisplayProperties2KHR fp_vkGetPhysicalDeviceDisplayProperties2KHR = nullptr; #else - void * fp_vkGetPhysicalDeviceDisplayProperties2KHR{}; + void* fp_vkGetPhysicalDeviceDisplayProperties2KHR{}; #endif #if (defined(VK_KHR_get_display_properties2)) PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR fp_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = nullptr; #else - void * fp_vkGetPhysicalDeviceDisplayPlaneProperties2KHR{}; + void* fp_vkGetPhysicalDeviceDisplayPlaneProperties2KHR{}; #endif #if (defined(VK_KHR_get_display_properties2)) PFN_vkGetDisplayModeProperties2KHR fp_vkGetDisplayModeProperties2KHR = nullptr; #else - void * fp_vkGetDisplayModeProperties2KHR{}; + void* fp_vkGetDisplayModeProperties2KHR{}; #endif #if (defined(VK_KHR_get_display_properties2)) PFN_vkGetDisplayPlaneCapabilities2KHR fp_vkGetDisplayPlaneCapabilities2KHR = nullptr; #else - void * fp_vkGetDisplayPlaneCapabilities2KHR{}; + void* fp_vkGetDisplayPlaneCapabilities2KHR{}; #endif #if (defined(VK_KHR_calibrated_timestamps)) PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR fp_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR{}; + void* fp_vkGetPhysicalDeviceCalibrateableTimeDomainsKHR{}; #endif #if (defined(VK_EXT_debug_utils)) PFN_vkCreateDebugUtilsMessengerEXT fp_vkCreateDebugUtilsMessengerEXT = nullptr; #else - void * fp_vkCreateDebugUtilsMessengerEXT{}; + void* fp_vkCreateDebugUtilsMessengerEXT{}; #endif #if (defined(VK_EXT_debug_utils)) PFN_vkDestroyDebugUtilsMessengerEXT fp_vkDestroyDebugUtilsMessengerEXT = nullptr; #else - void * fp_vkDestroyDebugUtilsMessengerEXT{}; + void* fp_vkDestroyDebugUtilsMessengerEXT{}; #endif #if (defined(VK_EXT_debug_utils)) PFN_vkSubmitDebugUtilsMessageEXT fp_vkSubmitDebugUtilsMessageEXT = nullptr; #else - void * fp_vkSubmitDebugUtilsMessageEXT{}; + void* fp_vkSubmitDebugUtilsMessageEXT{}; #endif #if (defined(VK_NV_cooperative_matrix)) PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = nullptr; #else - void * fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV{}; + void* fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV{}; #endif #if (defined(VK_EXT_full_screen_exclusive)) PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT fp_vkGetPhysicalDeviceSurfacePresentModes2EXT = nullptr; #else - void * fp_vkGetPhysicalDeviceSurfacePresentModes2EXT{}; + void* fp_vkGetPhysicalDeviceSurfacePresentModes2EXT{}; #endif #if (defined(VK_KHR_performance_query)) - PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR fp_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = nullptr; + PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR + fp_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = nullptr; #else - void * fp_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR{}; + void* fp_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR{}; #endif #if (defined(VK_KHR_performance_query)) - PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR fp_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = nullptr; + PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR + fp_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR{}; + void* fp_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR{}; #endif #if (defined(VK_EXT_headless_surface)) PFN_vkCreateHeadlessSurfaceEXT fp_vkCreateHeadlessSurfaceEXT = nullptr; #else - void * fp_vkCreateHeadlessSurfaceEXT{}; + void* fp_vkCreateHeadlessSurfaceEXT{}; #endif #if (defined(VK_NV_coverage_reduction_mode)) - PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV fp_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = nullptr; + PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV + fp_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = nullptr; #else - void * fp_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV{}; + void* fp_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkGetPhysicalDeviceToolProperties fp_vkGetPhysicalDeviceToolProperties = nullptr; #else - void * fp_vkGetPhysicalDeviceToolProperties{}; + void* fp_vkGetPhysicalDeviceToolProperties{}; #endif #if (defined(VK_KHR_object_refresh)) PFN_vkGetPhysicalDeviceRefreshableObjectTypesKHR fp_vkGetPhysicalDeviceRefreshableObjectTypesKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceRefreshableObjectTypesKHR{}; + void* fp_vkGetPhysicalDeviceRefreshableObjectTypesKHR{}; #endif #if (defined(VK_KHR_fragment_shading_rate)) PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR fp_vkGetPhysicalDeviceFragmentShadingRatesKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceFragmentShadingRatesKHR{}; + void* fp_vkGetPhysicalDeviceFragmentShadingRatesKHR{}; #endif #if (defined(VK_KHR_video_queue)) PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR fp_vkGetPhysicalDeviceVideoCapabilitiesKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceVideoCapabilitiesKHR{}; + void* fp_vkGetPhysicalDeviceVideoCapabilitiesKHR{}; #endif #if (defined(VK_KHR_video_queue)) PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR fp_vkGetPhysicalDeviceVideoFormatPropertiesKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceVideoFormatPropertiesKHR{}; + void* fp_vkGetPhysicalDeviceVideoFormatPropertiesKHR{}; #endif #if (defined(VK_KHR_video_encode_queue)) - PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR fp_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = nullptr; + PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR + fp_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR{}; + void* fp_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR{}; #endif #if (defined(VK_EXT_acquire_drm_display)) PFN_vkAcquireDrmDisplayEXT fp_vkAcquireDrmDisplayEXT = nullptr; #else - void * fp_vkAcquireDrmDisplayEXT{}; + void* fp_vkAcquireDrmDisplayEXT{}; #endif #if (defined(VK_EXT_acquire_drm_display)) PFN_vkGetDrmDisplayEXT fp_vkGetDrmDisplayEXT = nullptr; #else - void * fp_vkGetDrmDisplayEXT{}; + void* fp_vkGetDrmDisplayEXT{}; #endif #if (defined(VK_NV_optical_flow)) PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV fp_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = nullptr; #else - void * fp_vkGetPhysicalDeviceOpticalFlowImageFormatsNV{}; + void* fp_vkGetPhysicalDeviceOpticalFlowImageFormatsNV{}; #endif #if (defined(VK_KHR_cooperative_matrix)) - PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = nullptr; + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = + nullptr; #else - void * fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR{}; + void* fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR{}; #endif #if (defined(VK_KHR_get_physical_device_properties2)) PFN_vkGetPhysicalDeviceFeatures2KHR fp_vkGetPhysicalDeviceFeatures2KHR = nullptr; #else - void * fp_vkGetPhysicalDeviceFeatures2KHR{}; + void* fp_vkGetPhysicalDeviceFeatures2KHR{}; #endif #if (defined(VK_KHR_get_physical_device_properties2)) PFN_vkGetPhysicalDeviceProperties2KHR fp_vkGetPhysicalDeviceProperties2KHR = nullptr; #else - void * fp_vkGetPhysicalDeviceProperties2KHR{}; + void* fp_vkGetPhysicalDeviceProperties2KHR{}; #endif #if (defined(VK_KHR_get_physical_device_properties2)) PFN_vkGetPhysicalDeviceFormatProperties2KHR fp_vkGetPhysicalDeviceFormatProperties2KHR = nullptr; #else - void * fp_vkGetPhysicalDeviceFormatProperties2KHR{}; + void* fp_vkGetPhysicalDeviceFormatProperties2KHR{}; #endif #if (defined(VK_KHR_get_physical_device_properties2)) PFN_vkGetPhysicalDeviceImageFormatProperties2KHR fp_vkGetPhysicalDeviceImageFormatProperties2KHR = nullptr; #else - void * fp_vkGetPhysicalDeviceImageFormatProperties2KHR{}; + void* fp_vkGetPhysicalDeviceImageFormatProperties2KHR{}; #endif #if (defined(VK_KHR_get_physical_device_properties2)) PFN_vkGetPhysicalDeviceQueueFamilyProperties2KHR fp_vkGetPhysicalDeviceQueueFamilyProperties2KHR = nullptr; #else - void * fp_vkGetPhysicalDeviceQueueFamilyProperties2KHR{}; + void* fp_vkGetPhysicalDeviceQueueFamilyProperties2KHR{}; #endif #if (defined(VK_KHR_get_physical_device_properties2)) PFN_vkGetPhysicalDeviceMemoryProperties2KHR fp_vkGetPhysicalDeviceMemoryProperties2KHR = nullptr; #else - void * fp_vkGetPhysicalDeviceMemoryProperties2KHR{}; + void* fp_vkGetPhysicalDeviceMemoryProperties2KHR{}; #endif #if (defined(VK_KHR_get_physical_device_properties2)) - PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR fp_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = nullptr; + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2KHR fp_vkGetPhysicalDeviceSparseImageFormatProperties2KHR = + nullptr; #else - void * fp_vkGetPhysicalDeviceSparseImageFormatProperties2KHR{}; + void* fp_vkGetPhysicalDeviceSparseImageFormatProperties2KHR{}; #endif #if (defined(VK_KHR_external_memory_capabilities)) PFN_vkGetPhysicalDeviceExternalBufferPropertiesKHR fp_vkGetPhysicalDeviceExternalBufferPropertiesKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceExternalBufferPropertiesKHR{}; + void* fp_vkGetPhysicalDeviceExternalBufferPropertiesKHR{}; #endif #if (defined(VK_KHR_external_semaphore_capabilities)) - PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR fp_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = nullptr; + PFN_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR fp_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR = + nullptr; #else - void * fp_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR{}; + void* fp_vkGetPhysicalDeviceExternalSemaphorePropertiesKHR{}; #endif #if (defined(VK_KHR_external_fence_capabilities)) PFN_vkGetPhysicalDeviceExternalFencePropertiesKHR fp_vkGetPhysicalDeviceExternalFencePropertiesKHR = nullptr; #else - void * fp_vkGetPhysicalDeviceExternalFencePropertiesKHR{}; + void* fp_vkGetPhysicalDeviceExternalFencePropertiesKHR{}; #endif #if (defined(VK_KHR_device_group_creation)) PFN_vkEnumeratePhysicalDeviceGroupsKHR fp_vkEnumeratePhysicalDeviceGroupsKHR = nullptr; #else - void * fp_vkEnumeratePhysicalDeviceGroupsKHR{}; + void* fp_vkEnumeratePhysicalDeviceGroupsKHR{}; #endif #if (defined(VK_EXT_calibrated_timestamps)) PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT fp_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = nullptr; #else - void * fp_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT{}; + void* fp_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT{}; #endif #if (defined(VK_EXT_tooling_info)) PFN_vkGetPhysicalDeviceToolPropertiesEXT fp_vkGetPhysicalDeviceToolPropertiesEXT = nullptr; #else - void * fp_vkGetPhysicalDeviceToolPropertiesEXT{}; + void* fp_vkGetPhysicalDeviceToolPropertiesEXT{}; #endif - bool is_populated() const { return populated; } + bool is_populated() const { return populated; } VkInstance instance = VK_NULL_HANDLE; -private: - bool populated = false; + + private: + bool populated = false; }; -struct DispatchTable { +struct DispatchTable +{ DispatchTable() = default; - DispatchTable(VkDevice device, PFN_vkGetDeviceProcAddr procAddr) : device(device), populated(true) { + DispatchTable(VkDevice device, PFN_vkGetDeviceProcAddr procAddr) : device(device), populated(true) + { fp_vkGetDeviceProcAddr = procAddr; - fp_vkGetDeviceQueue = reinterpret_cast(procAddr(device, "vkGetDeviceQueue")); - fp_vkQueueSubmit = reinterpret_cast(procAddr(device, "vkQueueSubmit")); - fp_vkQueueWaitIdle = reinterpret_cast(procAddr(device, "vkQueueWaitIdle")); - fp_vkDeviceWaitIdle = reinterpret_cast(procAddr(device, "vkDeviceWaitIdle")); - fp_vkAllocateMemory = reinterpret_cast(procAddr(device, "vkAllocateMemory")); - fp_vkFreeMemory = reinterpret_cast(procAddr(device, "vkFreeMemory")); - fp_vkMapMemory = reinterpret_cast(procAddr(device, "vkMapMemory")); - fp_vkUnmapMemory = reinterpret_cast(procAddr(device, "vkUnmapMemory")); - fp_vkFlushMappedMemoryRanges = reinterpret_cast(procAddr(device, "vkFlushMappedMemoryRanges")); - fp_vkInvalidateMappedMemoryRanges = reinterpret_cast(procAddr(device, "vkInvalidateMappedMemoryRanges")); - fp_vkGetDeviceMemoryCommitment = reinterpret_cast(procAddr(device, "vkGetDeviceMemoryCommitment")); - fp_vkGetBufferMemoryRequirements = reinterpret_cast(procAddr(device, "vkGetBufferMemoryRequirements")); + fp_vkGetDeviceQueue = reinterpret_cast(procAddr(device, "vkGetDeviceQueue")); + fp_vkQueueSubmit = reinterpret_cast(procAddr(device, "vkQueueSubmit")); + fp_vkQueueWaitIdle = reinterpret_cast(procAddr(device, "vkQueueWaitIdle")); + fp_vkDeviceWaitIdle = reinterpret_cast(procAddr(device, "vkDeviceWaitIdle")); + fp_vkAllocateMemory = reinterpret_cast(procAddr(device, "vkAllocateMemory")); + fp_vkFreeMemory = reinterpret_cast(procAddr(device, "vkFreeMemory")); + fp_vkMapMemory = reinterpret_cast(procAddr(device, "vkMapMemory")); + fp_vkUnmapMemory = reinterpret_cast(procAddr(device, "vkUnmapMemory")); + fp_vkFlushMappedMemoryRanges = + reinterpret_cast(procAddr(device, "vkFlushMappedMemoryRanges")); + fp_vkInvalidateMappedMemoryRanges = + reinterpret_cast(procAddr(device, "vkInvalidateMappedMemoryRanges")); + fp_vkGetDeviceMemoryCommitment = + reinterpret_cast(procAddr(device, "vkGetDeviceMemoryCommitment")); + fp_vkGetBufferMemoryRequirements = + reinterpret_cast(procAddr(device, "vkGetBufferMemoryRequirements")); fp_vkBindBufferMemory = reinterpret_cast(procAddr(device, "vkBindBufferMemory")); - fp_vkGetImageMemoryRequirements = reinterpret_cast(procAddr(device, "vkGetImageMemoryRequirements")); + fp_vkGetImageMemoryRequirements = + reinterpret_cast(procAddr(device, "vkGetImageMemoryRequirements")); fp_vkBindImageMemory = reinterpret_cast(procAddr(device, "vkBindImageMemory")); - fp_vkGetImageSparseMemoryRequirements = reinterpret_cast(procAddr(device, "vkGetImageSparseMemoryRequirements")); - fp_vkQueueBindSparse = reinterpret_cast(procAddr(device, "vkQueueBindSparse")); - fp_vkCreateFence = reinterpret_cast(procAddr(device, "vkCreateFence")); - fp_vkDestroyFence = reinterpret_cast(procAddr(device, "vkDestroyFence")); - fp_vkResetFences = reinterpret_cast(procAddr(device, "vkResetFences")); - fp_vkGetFenceStatus = reinterpret_cast(procAddr(device, "vkGetFenceStatus")); - fp_vkWaitForFences = reinterpret_cast(procAddr(device, "vkWaitForFences")); - fp_vkCreateSemaphore = reinterpret_cast(procAddr(device, "vkCreateSemaphore")); + fp_vkGetImageSparseMemoryRequirements = reinterpret_cast( + procAddr(device, "vkGetImageSparseMemoryRequirements")); + fp_vkQueueBindSparse = reinterpret_cast(procAddr(device, "vkQueueBindSparse")); + fp_vkCreateFence = reinterpret_cast(procAddr(device, "vkCreateFence")); + fp_vkDestroyFence = reinterpret_cast(procAddr(device, "vkDestroyFence")); + fp_vkResetFences = reinterpret_cast(procAddr(device, "vkResetFences")); + fp_vkGetFenceStatus = reinterpret_cast(procAddr(device, "vkGetFenceStatus")); + fp_vkWaitForFences = reinterpret_cast(procAddr(device, "vkWaitForFences")); + fp_vkCreateSemaphore = reinterpret_cast(procAddr(device, "vkCreateSemaphore")); fp_vkDestroySemaphore = reinterpret_cast(procAddr(device, "vkDestroySemaphore")); - fp_vkCreateEvent = reinterpret_cast(procAddr(device, "vkCreateEvent")); - fp_vkDestroyEvent = reinterpret_cast(procAddr(device, "vkDestroyEvent")); - fp_vkGetEventStatus = reinterpret_cast(procAddr(device, "vkGetEventStatus")); - fp_vkSetEvent = reinterpret_cast(procAddr(device, "vkSetEvent")); - fp_vkResetEvent = reinterpret_cast(procAddr(device, "vkResetEvent")); - fp_vkCreateQueryPool = reinterpret_cast(procAddr(device, "vkCreateQueryPool")); + fp_vkCreateEvent = reinterpret_cast(procAddr(device, "vkCreateEvent")); + fp_vkDestroyEvent = reinterpret_cast(procAddr(device, "vkDestroyEvent")); + fp_vkGetEventStatus = reinterpret_cast(procAddr(device, "vkGetEventStatus")); + fp_vkSetEvent = reinterpret_cast(procAddr(device, "vkSetEvent")); + fp_vkResetEvent = reinterpret_cast(procAddr(device, "vkResetEvent")); + fp_vkCreateQueryPool = reinterpret_cast(procAddr(device, "vkCreateQueryPool")); fp_vkDestroyQueryPool = reinterpret_cast(procAddr(device, "vkDestroyQueryPool")); - fp_vkGetQueryPoolResults = reinterpret_cast(procAddr(device, "vkGetQueryPoolResults")); + fp_vkGetQueryPoolResults = + reinterpret_cast(procAddr(device, "vkGetQueryPoolResults")); #if (defined(VK_VERSION_1_2)) fp_vkResetQueryPool = reinterpret_cast(procAddr(device, "vkResetQueryPool")); #endif - fp_vkCreateBuffer = reinterpret_cast(procAddr(device, "vkCreateBuffer")); - fp_vkDestroyBuffer = reinterpret_cast(procAddr(device, "vkDestroyBuffer")); - fp_vkCreateBufferView = reinterpret_cast(procAddr(device, "vkCreateBufferView")); + fp_vkCreateBuffer = reinterpret_cast(procAddr(device, "vkCreateBuffer")); + fp_vkDestroyBuffer = reinterpret_cast(procAddr(device, "vkDestroyBuffer")); + fp_vkCreateBufferView = reinterpret_cast(procAddr(device, "vkCreateBufferView")); fp_vkDestroyBufferView = reinterpret_cast(procAddr(device, "vkDestroyBufferView")); - fp_vkCreateImage = reinterpret_cast(procAddr(device, "vkCreateImage")); - fp_vkDestroyImage = reinterpret_cast(procAddr(device, "vkDestroyImage")); - fp_vkGetImageSubresourceLayout = reinterpret_cast(procAddr(device, "vkGetImageSubresourceLayout")); - fp_vkCreateImageView = reinterpret_cast(procAddr(device, "vkCreateImageView")); - fp_vkDestroyImageView = reinterpret_cast(procAddr(device, "vkDestroyImageView")); + fp_vkCreateImage = reinterpret_cast(procAddr(device, "vkCreateImage")); + fp_vkDestroyImage = reinterpret_cast(procAddr(device, "vkDestroyImage")); + fp_vkGetImageSubresourceLayout = + reinterpret_cast(procAddr(device, "vkGetImageSubresourceLayout")); + fp_vkCreateImageView = reinterpret_cast(procAddr(device, "vkCreateImageView")); + fp_vkDestroyImageView = reinterpret_cast(procAddr(device, "vkDestroyImageView")); fp_vkCreateShaderModule = reinterpret_cast(procAddr(device, "vkCreateShaderModule")); - fp_vkDestroyShaderModule = reinterpret_cast(procAddr(device, "vkDestroyShaderModule")); - fp_vkCreatePipelineCache = reinterpret_cast(procAddr(device, "vkCreatePipelineCache")); - fp_vkDestroyPipelineCache = reinterpret_cast(procAddr(device, "vkDestroyPipelineCache")); - fp_vkGetPipelineCacheData = reinterpret_cast(procAddr(device, "vkGetPipelineCacheData")); - fp_vkMergePipelineCaches = reinterpret_cast(procAddr(device, "vkMergePipelineCaches")); + fp_vkDestroyShaderModule = + reinterpret_cast(procAddr(device, "vkDestroyShaderModule")); + fp_vkCreatePipelineCache = + reinterpret_cast(procAddr(device, "vkCreatePipelineCache")); + fp_vkDestroyPipelineCache = + reinterpret_cast(procAddr(device, "vkDestroyPipelineCache")); + fp_vkGetPipelineCacheData = + reinterpret_cast(procAddr(device, "vkGetPipelineCacheData")); + fp_vkMergePipelineCaches = + reinterpret_cast(procAddr(device, "vkMergePipelineCaches")); #if (defined(VK_KHR_pipeline_binary)) - fp_vkCreatePipelineBinariesKHR = reinterpret_cast(procAddr(device, "vkCreatePipelineBinariesKHR")); + fp_vkCreatePipelineBinariesKHR = + reinterpret_cast(procAddr(device, "vkCreatePipelineBinariesKHR")); #endif #if (defined(VK_KHR_pipeline_binary)) - fp_vkDestroyPipelineBinaryKHR = reinterpret_cast(procAddr(device, "vkDestroyPipelineBinaryKHR")); + fp_vkDestroyPipelineBinaryKHR = + reinterpret_cast(procAddr(device, "vkDestroyPipelineBinaryKHR")); #endif #if (defined(VK_KHR_pipeline_binary)) fp_vkGetPipelineKeyKHR = reinterpret_cast(procAddr(device, "vkGetPipelineKeyKHR")); #endif #if (defined(VK_KHR_pipeline_binary)) - fp_vkGetPipelineBinaryDataKHR = reinterpret_cast(procAddr(device, "vkGetPipelineBinaryDataKHR")); + fp_vkGetPipelineBinaryDataKHR = + reinterpret_cast(procAddr(device, "vkGetPipelineBinaryDataKHR")); #endif #if (defined(VK_KHR_pipeline_binary)) - fp_vkReleaseCapturedPipelineDataKHR = reinterpret_cast(procAddr(device, "vkReleaseCapturedPipelineDataKHR")); + fp_vkReleaseCapturedPipelineDataKHR = reinterpret_cast( + procAddr(device, "vkReleaseCapturedPipelineDataKHR")); #endif - fp_vkCreateGraphicsPipelines = reinterpret_cast(procAddr(device, "vkCreateGraphicsPipelines")); - fp_vkCreateComputePipelines = reinterpret_cast(procAddr(device, "vkCreateComputePipelines")); + fp_vkCreateGraphicsPipelines = + reinterpret_cast(procAddr(device, "vkCreateGraphicsPipelines")); + fp_vkCreateComputePipelines = + reinterpret_cast(procAddr(device, "vkCreateComputePipelines")); #if (defined(VK_HUAWEI_subpass_shading)) - fp_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = reinterpret_cast(procAddr(device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI")); + fp_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = + reinterpret_cast( + procAddr(device, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI")); #endif fp_vkDestroyPipeline = reinterpret_cast(procAddr(device, "vkDestroyPipeline")); - fp_vkCreatePipelineLayout = reinterpret_cast(procAddr(device, "vkCreatePipelineLayout")); - fp_vkDestroyPipelineLayout = reinterpret_cast(procAddr(device, "vkDestroyPipelineLayout")); - fp_vkCreateSampler = reinterpret_cast(procAddr(device, "vkCreateSampler")); + fp_vkCreatePipelineLayout = + reinterpret_cast(procAddr(device, "vkCreatePipelineLayout")); + fp_vkDestroyPipelineLayout = + reinterpret_cast(procAddr(device, "vkDestroyPipelineLayout")); + fp_vkCreateSampler = reinterpret_cast(procAddr(device, "vkCreateSampler")); fp_vkDestroySampler = reinterpret_cast(procAddr(device, "vkDestroySampler")); - fp_vkCreateDescriptorSetLayout = reinterpret_cast(procAddr(device, "vkCreateDescriptorSetLayout")); - fp_vkDestroyDescriptorSetLayout = reinterpret_cast(procAddr(device, "vkDestroyDescriptorSetLayout")); - fp_vkCreateDescriptorPool = reinterpret_cast(procAddr(device, "vkCreateDescriptorPool")); - fp_vkDestroyDescriptorPool = reinterpret_cast(procAddr(device, "vkDestroyDescriptorPool")); - fp_vkResetDescriptorPool = reinterpret_cast(procAddr(device, "vkResetDescriptorPool")); - fp_vkAllocateDescriptorSets = reinterpret_cast(procAddr(device, "vkAllocateDescriptorSets")); + fp_vkCreateDescriptorSetLayout = + reinterpret_cast(procAddr(device, "vkCreateDescriptorSetLayout")); + fp_vkDestroyDescriptorSetLayout = + reinterpret_cast(procAddr(device, "vkDestroyDescriptorSetLayout")); + fp_vkCreateDescriptorPool = + reinterpret_cast(procAddr(device, "vkCreateDescriptorPool")); + fp_vkDestroyDescriptorPool = + reinterpret_cast(procAddr(device, "vkDestroyDescriptorPool")); + fp_vkResetDescriptorPool = + reinterpret_cast(procAddr(device, "vkResetDescriptorPool")); + fp_vkAllocateDescriptorSets = + reinterpret_cast(procAddr(device, "vkAllocateDescriptorSets")); fp_vkFreeDescriptorSets = reinterpret_cast(procAddr(device, "vkFreeDescriptorSets")); - fp_vkUpdateDescriptorSets = reinterpret_cast(procAddr(device, "vkUpdateDescriptorSets")); - fp_vkCreateFramebuffer = reinterpret_cast(procAddr(device, "vkCreateFramebuffer")); + fp_vkUpdateDescriptorSets = + reinterpret_cast(procAddr(device, "vkUpdateDescriptorSets")); + fp_vkCreateFramebuffer = reinterpret_cast(procAddr(device, "vkCreateFramebuffer")); fp_vkDestroyFramebuffer = reinterpret_cast(procAddr(device, "vkDestroyFramebuffer")); - fp_vkCreateRenderPass = reinterpret_cast(procAddr(device, "vkCreateRenderPass")); - fp_vkDestroyRenderPass = reinterpret_cast(procAddr(device, "vkDestroyRenderPass")); - fp_vkGetRenderAreaGranularity = reinterpret_cast(procAddr(device, "vkGetRenderAreaGranularity")); + fp_vkCreateRenderPass = reinterpret_cast(procAddr(device, "vkCreateRenderPass")); + fp_vkDestroyRenderPass = reinterpret_cast(procAddr(device, "vkDestroyRenderPass")); + fp_vkGetRenderAreaGranularity = + reinterpret_cast(procAddr(device, "vkGetRenderAreaGranularity")); #if (defined(VK_KHR_maintenance5)) - fp_vkGetRenderingAreaGranularityKHR = reinterpret_cast(procAddr(device, "vkGetRenderingAreaGranularityKHR")); + fp_vkGetRenderingAreaGranularityKHR = reinterpret_cast( + procAddr(device, "vkGetRenderingAreaGranularityKHR")); #endif - fp_vkCreateCommandPool = reinterpret_cast(procAddr(device, "vkCreateCommandPool")); + fp_vkCreateCommandPool = reinterpret_cast(procAddr(device, "vkCreateCommandPool")); fp_vkDestroyCommandPool = reinterpret_cast(procAddr(device, "vkDestroyCommandPool")); - fp_vkResetCommandPool = reinterpret_cast(procAddr(device, "vkResetCommandPool")); - fp_vkAllocateCommandBuffers = reinterpret_cast(procAddr(device, "vkAllocateCommandBuffers")); + fp_vkResetCommandPool = reinterpret_cast(procAddr(device, "vkResetCommandPool")); + fp_vkAllocateCommandBuffers = + reinterpret_cast(procAddr(device, "vkAllocateCommandBuffers")); fp_vkFreeCommandBuffers = reinterpret_cast(procAddr(device, "vkFreeCommandBuffers")); fp_vkBeginCommandBuffer = reinterpret_cast(procAddr(device, "vkBeginCommandBuffer")); - fp_vkEndCommandBuffer = reinterpret_cast(procAddr(device, "vkEndCommandBuffer")); + fp_vkEndCommandBuffer = reinterpret_cast(procAddr(device, "vkEndCommandBuffer")); fp_vkResetCommandBuffer = reinterpret_cast(procAddr(device, "vkResetCommandBuffer")); - fp_vkCmdBindPipeline = reinterpret_cast(procAddr(device, "vkCmdBindPipeline")); + fp_vkCmdBindPipeline = reinterpret_cast(procAddr(device, "vkCmdBindPipeline")); #if (defined(VK_EXT_attachment_feedback_loop_dynamic_state)) - fp_vkCmdSetAttachmentFeedbackLoopEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetAttachmentFeedbackLoopEnableEXT")); + fp_vkCmdSetAttachmentFeedbackLoopEnableEXT = reinterpret_cast( + procAddr(device, "vkCmdSetAttachmentFeedbackLoopEnableEXT")); #endif - fp_vkCmdSetViewport = reinterpret_cast(procAddr(device, "vkCmdSetViewport")); - fp_vkCmdSetScissor = reinterpret_cast(procAddr(device, "vkCmdSetScissor")); + fp_vkCmdSetViewport = reinterpret_cast(procAddr(device, "vkCmdSetViewport")); + fp_vkCmdSetScissor = reinterpret_cast(procAddr(device, "vkCmdSetScissor")); fp_vkCmdSetLineWidth = reinterpret_cast(procAddr(device, "vkCmdSetLineWidth")); fp_vkCmdSetDepthBias = reinterpret_cast(procAddr(device, "vkCmdSetDepthBias")); - fp_vkCmdSetBlendConstants = reinterpret_cast(procAddr(device, "vkCmdSetBlendConstants")); + fp_vkCmdSetBlendConstants = + reinterpret_cast(procAddr(device, "vkCmdSetBlendConstants")); fp_vkCmdSetDepthBounds = reinterpret_cast(procAddr(device, "vkCmdSetDepthBounds")); - fp_vkCmdSetStencilCompareMask = reinterpret_cast(procAddr(device, "vkCmdSetStencilCompareMask")); - fp_vkCmdSetStencilWriteMask = reinterpret_cast(procAddr(device, "vkCmdSetStencilWriteMask")); - fp_vkCmdSetStencilReference = reinterpret_cast(procAddr(device, "vkCmdSetStencilReference")); - fp_vkCmdBindDescriptorSets = reinterpret_cast(procAddr(device, "vkCmdBindDescriptorSets")); + fp_vkCmdSetStencilCompareMask = + reinterpret_cast(procAddr(device, "vkCmdSetStencilCompareMask")); + fp_vkCmdSetStencilWriteMask = + reinterpret_cast(procAddr(device, "vkCmdSetStencilWriteMask")); + fp_vkCmdSetStencilReference = + reinterpret_cast(procAddr(device, "vkCmdSetStencilReference")); + fp_vkCmdBindDescriptorSets = + reinterpret_cast(procAddr(device, "vkCmdBindDescriptorSets")); fp_vkCmdBindIndexBuffer = reinterpret_cast(procAddr(device, "vkCmdBindIndexBuffer")); - fp_vkCmdBindVertexBuffers = reinterpret_cast(procAddr(device, "vkCmdBindVertexBuffers")); - fp_vkCmdDraw = reinterpret_cast(procAddr(device, "vkCmdDraw")); + fp_vkCmdBindVertexBuffers = + reinterpret_cast(procAddr(device, "vkCmdBindVertexBuffers")); + fp_vkCmdDraw = reinterpret_cast(procAddr(device, "vkCmdDraw")); fp_vkCmdDrawIndexed = reinterpret_cast(procAddr(device, "vkCmdDrawIndexed")); #if (defined(VK_EXT_multi_draw)) fp_vkCmdDrawMultiEXT = reinterpret_cast(procAddr(device, "vkCmdDrawMultiEXT")); #endif #if (defined(VK_EXT_multi_draw)) - fp_vkCmdDrawMultiIndexedEXT = reinterpret_cast(procAddr(device, "vkCmdDrawMultiIndexedEXT")); + fp_vkCmdDrawMultiIndexedEXT = + reinterpret_cast(procAddr(device, "vkCmdDrawMultiIndexedEXT")); #endif fp_vkCmdDrawIndirect = reinterpret_cast(procAddr(device, "vkCmdDrawIndirect")); - fp_vkCmdDrawIndexedIndirect = reinterpret_cast(procAddr(device, "vkCmdDrawIndexedIndirect")); + fp_vkCmdDrawIndexedIndirect = + reinterpret_cast(procAddr(device, "vkCmdDrawIndexedIndirect")); fp_vkCmdDispatch = reinterpret_cast(procAddr(device, "vkCmdDispatch")); - fp_vkCmdDispatchIndirect = reinterpret_cast(procAddr(device, "vkCmdDispatchIndirect")); + fp_vkCmdDispatchIndirect = + reinterpret_cast(procAddr(device, "vkCmdDispatchIndirect")); #if (defined(VK_HUAWEI_subpass_shading)) - fp_vkCmdSubpassShadingHUAWEI = reinterpret_cast(procAddr(device, "vkCmdSubpassShadingHUAWEI")); + fp_vkCmdSubpassShadingHUAWEI = + reinterpret_cast(procAddr(device, "vkCmdSubpassShadingHUAWEI")); #endif #if (defined(VK_HUAWEI_cluster_culling_shader)) - fp_vkCmdDrawClusterHUAWEI = reinterpret_cast(procAddr(device, "vkCmdDrawClusterHUAWEI")); + fp_vkCmdDrawClusterHUAWEI = + reinterpret_cast(procAddr(device, "vkCmdDrawClusterHUAWEI")); #endif #if (defined(VK_HUAWEI_cluster_culling_shader)) - fp_vkCmdDrawClusterIndirectHUAWEI = reinterpret_cast(procAddr(device, "vkCmdDrawClusterIndirectHUAWEI")); + fp_vkCmdDrawClusterIndirectHUAWEI = + reinterpret_cast(procAddr(device, "vkCmdDrawClusterIndirectHUAWEI")); #endif #if (defined(VK_NV_device_generated_commands_compute)) - fp_vkCmdUpdatePipelineIndirectBufferNV = reinterpret_cast(procAddr(device, "vkCmdUpdatePipelineIndirectBufferNV")); + fp_vkCmdUpdatePipelineIndirectBufferNV = reinterpret_cast( + procAddr(device, "vkCmdUpdatePipelineIndirectBufferNV")); #endif fp_vkCmdCopyBuffer = reinterpret_cast(procAddr(device, "vkCmdCopyBuffer")); - fp_vkCmdCopyImage = reinterpret_cast(procAddr(device, "vkCmdCopyImage")); - fp_vkCmdBlitImage = reinterpret_cast(procAddr(device, "vkCmdBlitImage")); - fp_vkCmdCopyBufferToImage = reinterpret_cast(procAddr(device, "vkCmdCopyBufferToImage")); - fp_vkCmdCopyImageToBuffer = reinterpret_cast(procAddr(device, "vkCmdCopyImageToBuffer")); + fp_vkCmdCopyImage = reinterpret_cast(procAddr(device, "vkCmdCopyImage")); + fp_vkCmdBlitImage = reinterpret_cast(procAddr(device, "vkCmdBlitImage")); + fp_vkCmdCopyBufferToImage = + reinterpret_cast(procAddr(device, "vkCmdCopyBufferToImage")); + fp_vkCmdCopyImageToBuffer = + reinterpret_cast(procAddr(device, "vkCmdCopyImageToBuffer")); #if (defined(VK_NV_copy_memory_indirect)) - fp_vkCmdCopyMemoryIndirectNV = reinterpret_cast(procAddr(device, "vkCmdCopyMemoryIndirectNV")); + fp_vkCmdCopyMemoryIndirectNV = + reinterpret_cast(procAddr(device, "vkCmdCopyMemoryIndirectNV")); #endif #if (defined(VK_NV_copy_memory_indirect)) - fp_vkCmdCopyMemoryToImageIndirectNV = reinterpret_cast(procAddr(device, "vkCmdCopyMemoryToImageIndirectNV")); + fp_vkCmdCopyMemoryToImageIndirectNV = reinterpret_cast( + procAddr(device, "vkCmdCopyMemoryToImageIndirectNV")); #endif - fp_vkCmdUpdateBuffer = reinterpret_cast(procAddr(device, "vkCmdUpdateBuffer")); - fp_vkCmdFillBuffer = reinterpret_cast(procAddr(device, "vkCmdFillBuffer")); + fp_vkCmdUpdateBuffer = reinterpret_cast(procAddr(device, "vkCmdUpdateBuffer")); + fp_vkCmdFillBuffer = reinterpret_cast(procAddr(device, "vkCmdFillBuffer")); fp_vkCmdClearColorImage = reinterpret_cast(procAddr(device, "vkCmdClearColorImage")); - fp_vkCmdClearDepthStencilImage = reinterpret_cast(procAddr(device, "vkCmdClearDepthStencilImage")); - fp_vkCmdClearAttachments = reinterpret_cast(procAddr(device, "vkCmdClearAttachments")); - fp_vkCmdResolveImage = reinterpret_cast(procAddr(device, "vkCmdResolveImage")); - fp_vkCmdSetEvent = reinterpret_cast(procAddr(device, "vkCmdSetEvent")); - fp_vkCmdResetEvent = reinterpret_cast(procAddr(device, "vkCmdResetEvent")); - fp_vkCmdWaitEvents = reinterpret_cast(procAddr(device, "vkCmdWaitEvents")); + fp_vkCmdClearDepthStencilImage = + reinterpret_cast(procAddr(device, "vkCmdClearDepthStencilImage")); + fp_vkCmdClearAttachments = + reinterpret_cast(procAddr(device, "vkCmdClearAttachments")); + fp_vkCmdResolveImage = reinterpret_cast(procAddr(device, "vkCmdResolveImage")); + fp_vkCmdSetEvent = reinterpret_cast(procAddr(device, "vkCmdSetEvent")); + fp_vkCmdResetEvent = reinterpret_cast(procAddr(device, "vkCmdResetEvent")); + fp_vkCmdWaitEvents = reinterpret_cast(procAddr(device, "vkCmdWaitEvents")); fp_vkCmdPipelineBarrier = reinterpret_cast(procAddr(device, "vkCmdPipelineBarrier")); - fp_vkCmdBeginQuery = reinterpret_cast(procAddr(device, "vkCmdBeginQuery")); - fp_vkCmdEndQuery = reinterpret_cast(procAddr(device, "vkCmdEndQuery")); + fp_vkCmdBeginQuery = reinterpret_cast(procAddr(device, "vkCmdBeginQuery")); + fp_vkCmdEndQuery = reinterpret_cast(procAddr(device, "vkCmdEndQuery")); #if (defined(VK_EXT_conditional_rendering)) - fp_vkCmdBeginConditionalRenderingEXT = reinterpret_cast(procAddr(device, "vkCmdBeginConditionalRenderingEXT")); + fp_vkCmdBeginConditionalRenderingEXT = reinterpret_cast( + procAddr(device, "vkCmdBeginConditionalRenderingEXT")); #endif #if (defined(VK_EXT_conditional_rendering)) - fp_vkCmdEndConditionalRenderingEXT = reinterpret_cast(procAddr(device, "vkCmdEndConditionalRenderingEXT")); + fp_vkCmdEndConditionalRenderingEXT = + reinterpret_cast(procAddr(device, "vkCmdEndConditionalRenderingEXT")); #endif fp_vkCmdResetQueryPool = reinterpret_cast(procAddr(device, "vkCmdResetQueryPool")); fp_vkCmdWriteTimestamp = reinterpret_cast(procAddr(device, "vkCmdWriteTimestamp")); - fp_vkCmdCopyQueryPoolResults = reinterpret_cast(procAddr(device, "vkCmdCopyQueryPoolResults")); - fp_vkCmdPushConstants = reinterpret_cast(procAddr(device, "vkCmdPushConstants")); + fp_vkCmdCopyQueryPoolResults = + reinterpret_cast(procAddr(device, "vkCmdCopyQueryPoolResults")); + fp_vkCmdPushConstants = reinterpret_cast(procAddr(device, "vkCmdPushConstants")); fp_vkCmdBeginRenderPass = reinterpret_cast(procAddr(device, "vkCmdBeginRenderPass")); - fp_vkCmdNextSubpass = reinterpret_cast(procAddr(device, "vkCmdNextSubpass")); - fp_vkCmdEndRenderPass = reinterpret_cast(procAddr(device, "vkCmdEndRenderPass")); + fp_vkCmdNextSubpass = reinterpret_cast(procAddr(device, "vkCmdNextSubpass")); + fp_vkCmdEndRenderPass = reinterpret_cast(procAddr(device, "vkCmdEndRenderPass")); fp_vkCmdExecuteCommands = reinterpret_cast(procAddr(device, "vkCmdExecuteCommands")); #if (defined(VK_KHR_display_swapchain)) - fp_vkCreateSharedSwapchainsKHR = reinterpret_cast(procAddr(device, "vkCreateSharedSwapchainsKHR")); + fp_vkCreateSharedSwapchainsKHR = + reinterpret_cast(procAddr(device, "vkCreateSharedSwapchainsKHR")); #endif #if (defined(VK_KHR_swapchain)) fp_vkCreateSwapchainKHR = reinterpret_cast(procAddr(device, "vkCreateSwapchainKHR")); #endif #if (defined(VK_KHR_swapchain)) - fp_vkDestroySwapchainKHR = reinterpret_cast(procAddr(device, "vkDestroySwapchainKHR")); + fp_vkDestroySwapchainKHR = + reinterpret_cast(procAddr(device, "vkDestroySwapchainKHR")); #endif #if (defined(VK_KHR_swapchain)) - fp_vkGetSwapchainImagesKHR = reinterpret_cast(procAddr(device, "vkGetSwapchainImagesKHR")); + fp_vkGetSwapchainImagesKHR = + reinterpret_cast(procAddr(device, "vkGetSwapchainImagesKHR")); #endif #if (defined(VK_KHR_swapchain)) - fp_vkAcquireNextImageKHR = reinterpret_cast(procAddr(device, "vkAcquireNextImageKHR")); + fp_vkAcquireNextImageKHR = + reinterpret_cast(procAddr(device, "vkAcquireNextImageKHR")); #endif #if (defined(VK_KHR_swapchain)) fp_vkQueuePresentKHR = reinterpret_cast(procAddr(device, "vkQueuePresentKHR")); #endif #if (defined(VK_EXT_debug_marker)) - fp_vkDebugMarkerSetObjectNameEXT = reinterpret_cast(procAddr(device, "vkDebugMarkerSetObjectNameEXT")); + fp_vkDebugMarkerSetObjectNameEXT = + reinterpret_cast(procAddr(device, "vkDebugMarkerSetObjectNameEXT")); #endif #if (defined(VK_EXT_debug_marker)) - fp_vkDebugMarkerSetObjectTagEXT = reinterpret_cast(procAddr(device, "vkDebugMarkerSetObjectTagEXT")); + fp_vkDebugMarkerSetObjectTagEXT = + reinterpret_cast(procAddr(device, "vkDebugMarkerSetObjectTagEXT")); #endif #if (defined(VK_EXT_debug_marker)) - fp_vkCmdDebugMarkerBeginEXT = reinterpret_cast(procAddr(device, "vkCmdDebugMarkerBeginEXT")); + fp_vkCmdDebugMarkerBeginEXT = + reinterpret_cast(procAddr(device, "vkCmdDebugMarkerBeginEXT")); #endif #if (defined(VK_EXT_debug_marker)) - fp_vkCmdDebugMarkerEndEXT = reinterpret_cast(procAddr(device, "vkCmdDebugMarkerEndEXT")); + fp_vkCmdDebugMarkerEndEXT = + reinterpret_cast(procAddr(device, "vkCmdDebugMarkerEndEXT")); #endif #if (defined(VK_EXT_debug_marker)) - fp_vkCmdDebugMarkerInsertEXT = reinterpret_cast(procAddr(device, "vkCmdDebugMarkerInsertEXT")); + fp_vkCmdDebugMarkerInsertEXT = + reinterpret_cast(procAddr(device, "vkCmdDebugMarkerInsertEXT")); #endif #if (defined(VK_NV_external_memory_win32)) - fp_vkGetMemoryWin32HandleNV = reinterpret_cast(procAddr(device, "vkGetMemoryWin32HandleNV")); + fp_vkGetMemoryWin32HandleNV = + reinterpret_cast(procAddr(device, "vkGetMemoryWin32HandleNV")); #endif #if (defined(VK_NV_device_generated_commands)) - fp_vkCmdExecuteGeneratedCommandsNV = reinterpret_cast(procAddr(device, "vkCmdExecuteGeneratedCommandsNV")); + fp_vkCmdExecuteGeneratedCommandsNV = + reinterpret_cast(procAddr(device, "vkCmdExecuteGeneratedCommandsNV")); #endif #if (defined(VK_NV_device_generated_commands)) - fp_vkCmdPreprocessGeneratedCommandsNV = reinterpret_cast(procAddr(device, "vkCmdPreprocessGeneratedCommandsNV")); + fp_vkCmdPreprocessGeneratedCommandsNV = reinterpret_cast( + procAddr(device, "vkCmdPreprocessGeneratedCommandsNV")); #endif #if (defined(VK_NV_device_generated_commands)) - fp_vkCmdBindPipelineShaderGroupNV = reinterpret_cast(procAddr(device, "vkCmdBindPipelineShaderGroupNV")); + fp_vkCmdBindPipelineShaderGroupNV = + reinterpret_cast(procAddr(device, "vkCmdBindPipelineShaderGroupNV")); #endif #if (defined(VK_NV_device_generated_commands)) - fp_vkGetGeneratedCommandsMemoryRequirementsNV = reinterpret_cast(procAddr(device, "vkGetGeneratedCommandsMemoryRequirementsNV")); + fp_vkGetGeneratedCommandsMemoryRequirementsNV = + reinterpret_cast( + procAddr(device, "vkGetGeneratedCommandsMemoryRequirementsNV")); #endif #if (defined(VK_NV_device_generated_commands)) - fp_vkCreateIndirectCommandsLayoutNV = reinterpret_cast(procAddr(device, "vkCreateIndirectCommandsLayoutNV")); + fp_vkCreateIndirectCommandsLayoutNV = reinterpret_cast( + procAddr(device, "vkCreateIndirectCommandsLayoutNV")); #endif #if (defined(VK_NV_device_generated_commands)) - fp_vkDestroyIndirectCommandsLayoutNV = reinterpret_cast(procAddr(device, "vkDestroyIndirectCommandsLayoutNV")); + fp_vkDestroyIndirectCommandsLayoutNV = reinterpret_cast( + procAddr(device, "vkDestroyIndirectCommandsLayoutNV")); #endif #if (defined(VK_EXT_device_generated_commands)) - fp_vkCmdExecuteGeneratedCommandsEXT = reinterpret_cast(procAddr(device, "vkCmdExecuteGeneratedCommandsEXT")); + fp_vkCmdExecuteGeneratedCommandsEXT = reinterpret_cast( + procAddr(device, "vkCmdExecuteGeneratedCommandsEXT")); #endif #if (defined(VK_EXT_device_generated_commands)) - fp_vkCmdPreprocessGeneratedCommandsEXT = reinterpret_cast(procAddr(device, "vkCmdPreprocessGeneratedCommandsEXT")); + fp_vkCmdPreprocessGeneratedCommandsEXT = reinterpret_cast( + procAddr(device, "vkCmdPreprocessGeneratedCommandsEXT")); #endif #if (defined(VK_EXT_device_generated_commands)) - fp_vkGetGeneratedCommandsMemoryRequirementsEXT = reinterpret_cast(procAddr(device, "vkGetGeneratedCommandsMemoryRequirementsEXT")); + fp_vkGetGeneratedCommandsMemoryRequirementsEXT = + reinterpret_cast( + procAddr(device, "vkGetGeneratedCommandsMemoryRequirementsEXT")); #endif #if (defined(VK_EXT_device_generated_commands)) - fp_vkCreateIndirectCommandsLayoutEXT = reinterpret_cast(procAddr(device, "vkCreateIndirectCommandsLayoutEXT")); + fp_vkCreateIndirectCommandsLayoutEXT = reinterpret_cast( + procAddr(device, "vkCreateIndirectCommandsLayoutEXT")); #endif #if (defined(VK_EXT_device_generated_commands)) - fp_vkDestroyIndirectCommandsLayoutEXT = reinterpret_cast(procAddr(device, "vkDestroyIndirectCommandsLayoutEXT")); + fp_vkDestroyIndirectCommandsLayoutEXT = reinterpret_cast( + procAddr(device, "vkDestroyIndirectCommandsLayoutEXT")); #endif #if (defined(VK_EXT_device_generated_commands)) - fp_vkCreateIndirectExecutionSetEXT = reinterpret_cast(procAddr(device, "vkCreateIndirectExecutionSetEXT")); + fp_vkCreateIndirectExecutionSetEXT = + reinterpret_cast(procAddr(device, "vkCreateIndirectExecutionSetEXT")); #endif #if (defined(VK_EXT_device_generated_commands)) - fp_vkDestroyIndirectExecutionSetEXT = reinterpret_cast(procAddr(device, "vkDestroyIndirectExecutionSetEXT")); + fp_vkDestroyIndirectExecutionSetEXT = reinterpret_cast( + procAddr(device, "vkDestroyIndirectExecutionSetEXT")); #endif #if (defined(VK_EXT_device_generated_commands)) - fp_vkUpdateIndirectExecutionSetPipelineEXT = reinterpret_cast(procAddr(device, "vkUpdateIndirectExecutionSetPipelineEXT")); + fp_vkUpdateIndirectExecutionSetPipelineEXT = reinterpret_cast( + procAddr(device, "vkUpdateIndirectExecutionSetPipelineEXT")); #endif #if (defined(VK_EXT_device_generated_commands)) - fp_vkUpdateIndirectExecutionSetShaderEXT = reinterpret_cast(procAddr(device, "vkUpdateIndirectExecutionSetShaderEXT")); + fp_vkUpdateIndirectExecutionSetShaderEXT = reinterpret_cast( + procAddr(device, "vkUpdateIndirectExecutionSetShaderEXT")); #endif #if (defined(VK_KHR_push_descriptor)) - fp_vkCmdPushDescriptorSetKHR = reinterpret_cast(procAddr(device, "vkCmdPushDescriptorSetKHR")); + fp_vkCmdPushDescriptorSetKHR = + reinterpret_cast(procAddr(device, "vkCmdPushDescriptorSetKHR")); #endif #if (defined(VK_VERSION_1_1)) fp_vkTrimCommandPool = reinterpret_cast(procAddr(device, "vkTrimCommandPool")); #endif #if (defined(VK_KHR_external_memory_win32)) - fp_vkGetMemoryWin32HandleKHR = reinterpret_cast(procAddr(device, "vkGetMemoryWin32HandleKHR")); + fp_vkGetMemoryWin32HandleKHR = + reinterpret_cast(procAddr(device, "vkGetMemoryWin32HandleKHR")); #endif #if (defined(VK_KHR_external_memory_win32)) - fp_vkGetMemoryWin32HandlePropertiesKHR = reinterpret_cast(procAddr(device, "vkGetMemoryWin32HandlePropertiesKHR")); + fp_vkGetMemoryWin32HandlePropertiesKHR = reinterpret_cast( + procAddr(device, "vkGetMemoryWin32HandlePropertiesKHR")); #endif #if (defined(VK_KHR_external_memory_fd)) fp_vkGetMemoryFdKHR = reinterpret_cast(procAddr(device, "vkGetMemoryFdKHR")); #endif #if (defined(VK_KHR_external_memory_fd)) - fp_vkGetMemoryFdPropertiesKHR = reinterpret_cast(procAddr(device, "vkGetMemoryFdPropertiesKHR")); + fp_vkGetMemoryFdPropertiesKHR = + reinterpret_cast(procAddr(device, "vkGetMemoryFdPropertiesKHR")); #endif #if (defined(VK_FUCHSIA_external_memory)) - fp_vkGetMemoryZirconHandleFUCHSIA = reinterpret_cast(procAddr(device, "vkGetMemoryZirconHandleFUCHSIA")); + fp_vkGetMemoryZirconHandleFUCHSIA = + reinterpret_cast(procAddr(device, "vkGetMemoryZirconHandleFUCHSIA")); #endif #if (defined(VK_FUCHSIA_external_memory)) - fp_vkGetMemoryZirconHandlePropertiesFUCHSIA = reinterpret_cast(procAddr(device, "vkGetMemoryZirconHandlePropertiesFUCHSIA")); + fp_vkGetMemoryZirconHandlePropertiesFUCHSIA = reinterpret_cast( + procAddr(device, "vkGetMemoryZirconHandlePropertiesFUCHSIA")); #endif #if (defined(VK_NV_external_memory_rdma)) - fp_vkGetMemoryRemoteAddressNV = reinterpret_cast(procAddr(device, "vkGetMemoryRemoteAddressNV")); + fp_vkGetMemoryRemoteAddressNV = + reinterpret_cast(procAddr(device, "vkGetMemoryRemoteAddressNV")); #endif #if (defined(VK_NV_external_memory_sci_buf)) fp_vkGetMemorySciBufNV = reinterpret_cast(procAddr(device, "vkGetMemorySciBufNV")); #endif #if (defined(VK_KHR_external_semaphore_win32)) - fp_vkGetSemaphoreWin32HandleKHR = reinterpret_cast(procAddr(device, "vkGetSemaphoreWin32HandleKHR")); + fp_vkGetSemaphoreWin32HandleKHR = + reinterpret_cast(procAddr(device, "vkGetSemaphoreWin32HandleKHR")); #endif #if (defined(VK_KHR_external_semaphore_win32)) - fp_vkImportSemaphoreWin32HandleKHR = reinterpret_cast(procAddr(device, "vkImportSemaphoreWin32HandleKHR")); + fp_vkImportSemaphoreWin32HandleKHR = + reinterpret_cast(procAddr(device, "vkImportSemaphoreWin32HandleKHR")); #endif #if (defined(VK_KHR_external_semaphore_fd)) fp_vkGetSemaphoreFdKHR = reinterpret_cast(procAddr(device, "vkGetSemaphoreFdKHR")); #endif #if (defined(VK_KHR_external_semaphore_fd)) - fp_vkImportSemaphoreFdKHR = reinterpret_cast(procAddr(device, "vkImportSemaphoreFdKHR")); + fp_vkImportSemaphoreFdKHR = + reinterpret_cast(procAddr(device, "vkImportSemaphoreFdKHR")); #endif #if (defined(VK_FUCHSIA_external_semaphore)) - fp_vkGetSemaphoreZirconHandleFUCHSIA = reinterpret_cast(procAddr(device, "vkGetSemaphoreZirconHandleFUCHSIA")); + fp_vkGetSemaphoreZirconHandleFUCHSIA = reinterpret_cast( + procAddr(device, "vkGetSemaphoreZirconHandleFUCHSIA")); #endif #if (defined(VK_FUCHSIA_external_semaphore)) - fp_vkImportSemaphoreZirconHandleFUCHSIA = reinterpret_cast(procAddr(device, "vkImportSemaphoreZirconHandleFUCHSIA")); + fp_vkImportSemaphoreZirconHandleFUCHSIA = reinterpret_cast( + procAddr(device, "vkImportSemaphoreZirconHandleFUCHSIA")); #endif #if (defined(VK_KHR_external_fence_win32)) - fp_vkGetFenceWin32HandleKHR = reinterpret_cast(procAddr(device, "vkGetFenceWin32HandleKHR")); + fp_vkGetFenceWin32HandleKHR = + reinterpret_cast(procAddr(device, "vkGetFenceWin32HandleKHR")); #endif #if (defined(VK_KHR_external_fence_win32)) - fp_vkImportFenceWin32HandleKHR = reinterpret_cast(procAddr(device, "vkImportFenceWin32HandleKHR")); + fp_vkImportFenceWin32HandleKHR = + reinterpret_cast(procAddr(device, "vkImportFenceWin32HandleKHR")); #endif #if (defined(VK_KHR_external_fence_fd)) fp_vkGetFenceFdKHR = reinterpret_cast(procAddr(device, "vkGetFenceFdKHR")); @@ -1665,43 +2290,56 @@ struct DispatchTable { fp_vkImportFenceFdKHR = reinterpret_cast(procAddr(device, "vkImportFenceFdKHR")); #endif #if (defined(VK_NV_external_sci_sync)) || (defined(VK_NV_external_sci_sync2)) - fp_vkGetFenceSciSyncFenceNV = reinterpret_cast(procAddr(device, "vkGetFenceSciSyncFenceNV")); + fp_vkGetFenceSciSyncFenceNV = + reinterpret_cast(procAddr(device, "vkGetFenceSciSyncFenceNV")); #endif #if (defined(VK_NV_external_sci_sync)) || (defined(VK_NV_external_sci_sync2)) - fp_vkGetFenceSciSyncObjNV = reinterpret_cast(procAddr(device, "vkGetFenceSciSyncObjNV")); + fp_vkGetFenceSciSyncObjNV = + reinterpret_cast(procAddr(device, "vkGetFenceSciSyncObjNV")); #endif #if (defined(VK_NV_external_sci_sync)) || (defined(VK_NV_external_sci_sync2)) - fp_vkImportFenceSciSyncFenceNV = reinterpret_cast(procAddr(device, "vkImportFenceSciSyncFenceNV")); + fp_vkImportFenceSciSyncFenceNV = + reinterpret_cast(procAddr(device, "vkImportFenceSciSyncFenceNV")); #endif #if (defined(VK_NV_external_sci_sync)) || (defined(VK_NV_external_sci_sync2)) - fp_vkImportFenceSciSyncObjNV = reinterpret_cast(procAddr(device, "vkImportFenceSciSyncObjNV")); + fp_vkImportFenceSciSyncObjNV = + reinterpret_cast(procAddr(device, "vkImportFenceSciSyncObjNV")); #endif #if (defined(VK_NV_external_sci_sync)) - fp_vkGetSemaphoreSciSyncObjNV = reinterpret_cast(procAddr(device, "vkGetSemaphoreSciSyncObjNV")); + fp_vkGetSemaphoreSciSyncObjNV = + reinterpret_cast(procAddr(device, "vkGetSemaphoreSciSyncObjNV")); #endif #if (defined(VK_NV_external_sci_sync)) - fp_vkImportSemaphoreSciSyncObjNV = reinterpret_cast(procAddr(device, "vkImportSemaphoreSciSyncObjNV")); + fp_vkImportSemaphoreSciSyncObjNV = + reinterpret_cast(procAddr(device, "vkImportSemaphoreSciSyncObjNV")); #endif #if (defined(VK_NV_external_sci_sync2)) - fp_vkCreateSemaphoreSciSyncPoolNV = reinterpret_cast(procAddr(device, "vkCreateSemaphoreSciSyncPoolNV")); + fp_vkCreateSemaphoreSciSyncPoolNV = + reinterpret_cast(procAddr(device, "vkCreateSemaphoreSciSyncPoolNV")); #endif #if (defined(VK_NV_external_sci_sync2)) - fp_vkDestroySemaphoreSciSyncPoolNV = reinterpret_cast(procAddr(device, "vkDestroySemaphoreSciSyncPoolNV")); + fp_vkDestroySemaphoreSciSyncPoolNV = + reinterpret_cast(procAddr(device, "vkDestroySemaphoreSciSyncPoolNV")); #endif #if (defined(VK_EXT_display_control)) - fp_vkDisplayPowerControlEXT = reinterpret_cast(procAddr(device, "vkDisplayPowerControlEXT")); + fp_vkDisplayPowerControlEXT = + reinterpret_cast(procAddr(device, "vkDisplayPowerControlEXT")); #endif #if (defined(VK_EXT_display_control)) - fp_vkRegisterDeviceEventEXT = reinterpret_cast(procAddr(device, "vkRegisterDeviceEventEXT")); + fp_vkRegisterDeviceEventEXT = + reinterpret_cast(procAddr(device, "vkRegisterDeviceEventEXT")); #endif #if (defined(VK_EXT_display_control)) - fp_vkRegisterDisplayEventEXT = reinterpret_cast(procAddr(device, "vkRegisterDisplayEventEXT")); + fp_vkRegisterDisplayEventEXT = + reinterpret_cast(procAddr(device, "vkRegisterDisplayEventEXT")); #endif #if (defined(VK_EXT_display_control)) - fp_vkGetSwapchainCounterEXT = reinterpret_cast(procAddr(device, "vkGetSwapchainCounterEXT")); + fp_vkGetSwapchainCounterEXT = + reinterpret_cast(procAddr(device, "vkGetSwapchainCounterEXT")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkGetDeviceGroupPeerMemoryFeatures = reinterpret_cast(procAddr(device, "vkGetDeviceGroupPeerMemoryFeatures")); + fp_vkGetDeviceGroupPeerMemoryFeatures = reinterpret_cast( + procAddr(device, "vkGetDeviceGroupPeerMemoryFeatures")); #endif #if (defined(VK_VERSION_1_1)) fp_vkBindBufferMemory2 = reinterpret_cast(procAddr(device, "vkBindBufferMemory2")); @@ -1713,109 +2351,141 @@ struct DispatchTable { fp_vkCmdSetDeviceMask = reinterpret_cast(procAddr(device, "vkCmdSetDeviceMask")); #endif #if (defined(VK_KHR_swapchain)) || (defined(VK_KHR_device_group)) - fp_vkGetDeviceGroupPresentCapabilitiesKHR = reinterpret_cast(procAddr(device, "vkGetDeviceGroupPresentCapabilitiesKHR")); + fp_vkGetDeviceGroupPresentCapabilitiesKHR = reinterpret_cast( + procAddr(device, "vkGetDeviceGroupPresentCapabilitiesKHR")); #endif #if (defined(VK_KHR_swapchain)) || (defined(VK_KHR_device_group)) - fp_vkGetDeviceGroupSurfacePresentModesKHR = reinterpret_cast(procAddr(device, "vkGetDeviceGroupSurfacePresentModesKHR")); + fp_vkGetDeviceGroupSurfacePresentModesKHR = reinterpret_cast( + procAddr(device, "vkGetDeviceGroupSurfacePresentModesKHR")); #endif #if (defined(VK_KHR_swapchain)) || (defined(VK_KHR_device_group)) - fp_vkAcquireNextImage2KHR = reinterpret_cast(procAddr(device, "vkAcquireNextImage2KHR")); + fp_vkAcquireNextImage2KHR = + reinterpret_cast(procAddr(device, "vkAcquireNextImage2KHR")); #endif #if (defined(VK_VERSION_1_1)) fp_vkCmdDispatchBase = reinterpret_cast(procAddr(device, "vkCmdDispatchBase")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkCreateDescriptorUpdateTemplate = reinterpret_cast(procAddr(device, "vkCreateDescriptorUpdateTemplate")); + fp_vkCreateDescriptorUpdateTemplate = reinterpret_cast( + procAddr(device, "vkCreateDescriptorUpdateTemplate")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkDestroyDescriptorUpdateTemplate = reinterpret_cast(procAddr(device, "vkDestroyDescriptorUpdateTemplate")); + fp_vkDestroyDescriptorUpdateTemplate = reinterpret_cast( + procAddr(device, "vkDestroyDescriptorUpdateTemplate")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkUpdateDescriptorSetWithTemplate = reinterpret_cast(procAddr(device, "vkUpdateDescriptorSetWithTemplate")); + fp_vkUpdateDescriptorSetWithTemplate = reinterpret_cast( + procAddr(device, "vkUpdateDescriptorSetWithTemplate")); #endif #if (defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_descriptor_update_template)) - fp_vkCmdPushDescriptorSetWithTemplateKHR = reinterpret_cast(procAddr(device, "vkCmdPushDescriptorSetWithTemplateKHR")); + fp_vkCmdPushDescriptorSetWithTemplateKHR = reinterpret_cast( + procAddr(device, "vkCmdPushDescriptorSetWithTemplateKHR")); #endif #if (defined(VK_EXT_hdr_metadata)) fp_vkSetHdrMetadataEXT = reinterpret_cast(procAddr(device, "vkSetHdrMetadataEXT")); #endif #if (defined(VK_KHR_shared_presentable_image)) - fp_vkGetSwapchainStatusKHR = reinterpret_cast(procAddr(device, "vkGetSwapchainStatusKHR")); + fp_vkGetSwapchainStatusKHR = + reinterpret_cast(procAddr(device, "vkGetSwapchainStatusKHR")); #endif #if (defined(VK_GOOGLE_display_timing)) - fp_vkGetRefreshCycleDurationGOOGLE = reinterpret_cast(procAddr(device, "vkGetRefreshCycleDurationGOOGLE")); + fp_vkGetRefreshCycleDurationGOOGLE = + reinterpret_cast(procAddr(device, "vkGetRefreshCycleDurationGOOGLE")); #endif #if (defined(VK_GOOGLE_display_timing)) - fp_vkGetPastPresentationTimingGOOGLE = reinterpret_cast(procAddr(device, "vkGetPastPresentationTimingGOOGLE")); + fp_vkGetPastPresentationTimingGOOGLE = reinterpret_cast( + procAddr(device, "vkGetPastPresentationTimingGOOGLE")); #endif #if (defined(VK_NV_clip_space_w_scaling)) - fp_vkCmdSetViewportWScalingNV = reinterpret_cast(procAddr(device, "vkCmdSetViewportWScalingNV")); + fp_vkCmdSetViewportWScalingNV = + reinterpret_cast(procAddr(device, "vkCmdSetViewportWScalingNV")); #endif #if (defined(VK_EXT_discard_rectangles)) - fp_vkCmdSetDiscardRectangleEXT = reinterpret_cast(procAddr(device, "vkCmdSetDiscardRectangleEXT")); + fp_vkCmdSetDiscardRectangleEXT = + reinterpret_cast(procAddr(device, "vkCmdSetDiscardRectangleEXT")); #endif #if ((defined(VK_EXT_discard_rectangles))) && VK_HEADER_VERSION >= 241 - fp_vkCmdSetDiscardRectangleEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetDiscardRectangleEnableEXT")); + fp_vkCmdSetDiscardRectangleEnableEXT = reinterpret_cast( + procAddr(device, "vkCmdSetDiscardRectangleEnableEXT")); #endif #if ((defined(VK_EXT_discard_rectangles))) && VK_HEADER_VERSION >= 241 - fp_vkCmdSetDiscardRectangleModeEXT = reinterpret_cast(procAddr(device, "vkCmdSetDiscardRectangleModeEXT")); + fp_vkCmdSetDiscardRectangleModeEXT = + reinterpret_cast(procAddr(device, "vkCmdSetDiscardRectangleModeEXT")); #endif #if (defined(VK_EXT_sample_locations)) - fp_vkCmdSetSampleLocationsEXT = reinterpret_cast(procAddr(device, "vkCmdSetSampleLocationsEXT")); + fp_vkCmdSetSampleLocationsEXT = + reinterpret_cast(procAddr(device, "vkCmdSetSampleLocationsEXT")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkGetBufferMemoryRequirements2 = reinterpret_cast(procAddr(device, "vkGetBufferMemoryRequirements2")); + fp_vkGetBufferMemoryRequirements2 = + reinterpret_cast(procAddr(device, "vkGetBufferMemoryRequirements2")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkGetImageMemoryRequirements2 = reinterpret_cast(procAddr(device, "vkGetImageMemoryRequirements2")); + fp_vkGetImageMemoryRequirements2 = + reinterpret_cast(procAddr(device, "vkGetImageMemoryRequirements2")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkGetImageSparseMemoryRequirements2 = reinterpret_cast(procAddr(device, "vkGetImageSparseMemoryRequirements2")); + fp_vkGetImageSparseMemoryRequirements2 = reinterpret_cast( + procAddr(device, "vkGetImageSparseMemoryRequirements2")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkGetDeviceBufferMemoryRequirements = reinterpret_cast(procAddr(device, "vkGetDeviceBufferMemoryRequirements")); + fp_vkGetDeviceBufferMemoryRequirements = reinterpret_cast( + procAddr(device, "vkGetDeviceBufferMemoryRequirements")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkGetDeviceImageMemoryRequirements = reinterpret_cast(procAddr(device, "vkGetDeviceImageMemoryRequirements")); + fp_vkGetDeviceImageMemoryRequirements = reinterpret_cast( + procAddr(device, "vkGetDeviceImageMemoryRequirements")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkGetDeviceImageSparseMemoryRequirements = reinterpret_cast(procAddr(device, "vkGetDeviceImageSparseMemoryRequirements")); + fp_vkGetDeviceImageSparseMemoryRequirements = reinterpret_cast( + procAddr(device, "vkGetDeviceImageSparseMemoryRequirements")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkCreateSamplerYcbcrConversion = reinterpret_cast(procAddr(device, "vkCreateSamplerYcbcrConversion")); + fp_vkCreateSamplerYcbcrConversion = + reinterpret_cast(procAddr(device, "vkCreateSamplerYcbcrConversion")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkDestroySamplerYcbcrConversion = reinterpret_cast(procAddr(device, "vkDestroySamplerYcbcrConversion")); + fp_vkDestroySamplerYcbcrConversion = + reinterpret_cast(procAddr(device, "vkDestroySamplerYcbcrConversion")); #endif #if (defined(VK_VERSION_1_1)) fp_vkGetDeviceQueue2 = reinterpret_cast(procAddr(device, "vkGetDeviceQueue2")); #endif #if (defined(VK_EXT_validation_cache)) - fp_vkCreateValidationCacheEXT = reinterpret_cast(procAddr(device, "vkCreateValidationCacheEXT")); + fp_vkCreateValidationCacheEXT = + reinterpret_cast(procAddr(device, "vkCreateValidationCacheEXT")); #endif #if (defined(VK_EXT_validation_cache)) - fp_vkDestroyValidationCacheEXT = reinterpret_cast(procAddr(device, "vkDestroyValidationCacheEXT")); + fp_vkDestroyValidationCacheEXT = + reinterpret_cast(procAddr(device, "vkDestroyValidationCacheEXT")); #endif #if (defined(VK_EXT_validation_cache)) - fp_vkGetValidationCacheDataEXT = reinterpret_cast(procAddr(device, "vkGetValidationCacheDataEXT")); + fp_vkGetValidationCacheDataEXT = + reinterpret_cast(procAddr(device, "vkGetValidationCacheDataEXT")); #endif #if (defined(VK_EXT_validation_cache)) - fp_vkMergeValidationCachesEXT = reinterpret_cast(procAddr(device, "vkMergeValidationCachesEXT")); + fp_vkMergeValidationCachesEXT = + reinterpret_cast(procAddr(device, "vkMergeValidationCachesEXT")); #endif #if (defined(VK_VERSION_1_1)) - fp_vkGetDescriptorSetLayoutSupport = reinterpret_cast(procAddr(device, "vkGetDescriptorSetLayoutSupport")); + fp_vkGetDescriptorSetLayoutSupport = + reinterpret_cast(procAddr(device, "vkGetDescriptorSetLayoutSupport")); #endif #if (defined(VK_ANDROID_native_buffer)) - fp_vkGetSwapchainGrallocUsageANDROID = reinterpret_cast(procAddr(device, "vkGetSwapchainGrallocUsageANDROID")); + fp_vkGetSwapchainGrallocUsageANDROID = reinterpret_cast( + procAddr(device, "vkGetSwapchainGrallocUsageANDROID")); #endif #if (defined(VK_ANDROID_native_buffer)) - fp_vkGetSwapchainGrallocUsage2ANDROID = reinterpret_cast(procAddr(device, "vkGetSwapchainGrallocUsage2ANDROID")); + fp_vkGetSwapchainGrallocUsage2ANDROID = reinterpret_cast( + procAddr(device, "vkGetSwapchainGrallocUsage2ANDROID")); #endif #if (defined(VK_ANDROID_native_buffer)) - fp_vkAcquireImageANDROID = reinterpret_cast(procAddr(device, "vkAcquireImageANDROID")); + fp_vkAcquireImageANDROID = + reinterpret_cast(procAddr(device, "vkAcquireImageANDROID")); #endif #if (defined(VK_ANDROID_native_buffer)) - fp_vkQueueSignalReleaseImageANDROID = reinterpret_cast(procAddr(device, "vkQueueSignalReleaseImageANDROID")); + fp_vkQueueSignalReleaseImageANDROID = reinterpret_cast( + procAddr(device, "vkQueueSignalReleaseImageANDROID")); #endif #if (defined(VK_AMD_shader_info)) fp_vkGetShaderInfoAMD = reinterpret_cast(procAddr(device, "vkGetShaderInfoAMD")); @@ -1824,43 +2494,55 @@ struct DispatchTable { fp_vkSetLocalDimmingAMD = reinterpret_cast(procAddr(device, "vkSetLocalDimmingAMD")); #endif #if (defined(VK_KHR_calibrated_timestamps)) - fp_vkGetCalibratedTimestampsKHR = reinterpret_cast(procAddr(device, "vkGetCalibratedTimestampsKHR")); + fp_vkGetCalibratedTimestampsKHR = + reinterpret_cast(procAddr(device, "vkGetCalibratedTimestampsKHR")); #endif #if (defined(VK_EXT_debug_utils)) - fp_vkSetDebugUtilsObjectNameEXT = reinterpret_cast(procAddr(device, "vkSetDebugUtilsObjectNameEXT")); + fp_vkSetDebugUtilsObjectNameEXT = + reinterpret_cast(procAddr(device, "vkSetDebugUtilsObjectNameEXT")); #endif #if (defined(VK_EXT_debug_utils)) - fp_vkSetDebugUtilsObjectTagEXT = reinterpret_cast(procAddr(device, "vkSetDebugUtilsObjectTagEXT")); + fp_vkSetDebugUtilsObjectTagEXT = + reinterpret_cast(procAddr(device, "vkSetDebugUtilsObjectTagEXT")); #endif #if (defined(VK_EXT_debug_utils)) - fp_vkQueueBeginDebugUtilsLabelEXT = reinterpret_cast(procAddr(device, "vkQueueBeginDebugUtilsLabelEXT")); + fp_vkQueueBeginDebugUtilsLabelEXT = + reinterpret_cast(procAddr(device, "vkQueueBeginDebugUtilsLabelEXT")); #endif #if (defined(VK_EXT_debug_utils)) - fp_vkQueueEndDebugUtilsLabelEXT = reinterpret_cast(procAddr(device, "vkQueueEndDebugUtilsLabelEXT")); + fp_vkQueueEndDebugUtilsLabelEXT = + reinterpret_cast(procAddr(device, "vkQueueEndDebugUtilsLabelEXT")); #endif #if (defined(VK_EXT_debug_utils)) - fp_vkQueueInsertDebugUtilsLabelEXT = reinterpret_cast(procAddr(device, "vkQueueInsertDebugUtilsLabelEXT")); + fp_vkQueueInsertDebugUtilsLabelEXT = + reinterpret_cast(procAddr(device, "vkQueueInsertDebugUtilsLabelEXT")); #endif #if (defined(VK_EXT_debug_utils)) - fp_vkCmdBeginDebugUtilsLabelEXT = reinterpret_cast(procAddr(device, "vkCmdBeginDebugUtilsLabelEXT")); + fp_vkCmdBeginDebugUtilsLabelEXT = + reinterpret_cast(procAddr(device, "vkCmdBeginDebugUtilsLabelEXT")); #endif #if (defined(VK_EXT_debug_utils)) - fp_vkCmdEndDebugUtilsLabelEXT = reinterpret_cast(procAddr(device, "vkCmdEndDebugUtilsLabelEXT")); + fp_vkCmdEndDebugUtilsLabelEXT = + reinterpret_cast(procAddr(device, "vkCmdEndDebugUtilsLabelEXT")); #endif #if (defined(VK_EXT_debug_utils)) - fp_vkCmdInsertDebugUtilsLabelEXT = reinterpret_cast(procAddr(device, "vkCmdInsertDebugUtilsLabelEXT")); + fp_vkCmdInsertDebugUtilsLabelEXT = + reinterpret_cast(procAddr(device, "vkCmdInsertDebugUtilsLabelEXT")); #endif #if (defined(VK_EXT_external_memory_host)) - fp_vkGetMemoryHostPointerPropertiesEXT = reinterpret_cast(procAddr(device, "vkGetMemoryHostPointerPropertiesEXT")); + fp_vkGetMemoryHostPointerPropertiesEXT = reinterpret_cast( + procAddr(device, "vkGetMemoryHostPointerPropertiesEXT")); #endif #if (defined(VK_AMD_buffer_marker)) - fp_vkCmdWriteBufferMarkerAMD = reinterpret_cast(procAddr(device, "vkCmdWriteBufferMarkerAMD")); + fp_vkCmdWriteBufferMarkerAMD = + reinterpret_cast(procAddr(device, "vkCmdWriteBufferMarkerAMD")); #endif #if (defined(VK_VERSION_1_2)) fp_vkCreateRenderPass2 = reinterpret_cast(procAddr(device, "vkCreateRenderPass2")); #endif #if (defined(VK_VERSION_1_2)) - fp_vkCmdBeginRenderPass2 = reinterpret_cast(procAddr(device, "vkCmdBeginRenderPass2")); + fp_vkCmdBeginRenderPass2 = + reinterpret_cast(procAddr(device, "vkCmdBeginRenderPass2")); #endif #if (defined(VK_VERSION_1_2)) fp_vkCmdNextSubpass2 = reinterpret_cast(procAddr(device, "vkCmdNextSubpass2")); @@ -1869,7 +2551,8 @@ struct DispatchTable { fp_vkCmdEndRenderPass2 = reinterpret_cast(procAddr(device, "vkCmdEndRenderPass2")); #endif #if (defined(VK_VERSION_1_2)) - fp_vkGetSemaphoreCounterValue = reinterpret_cast(procAddr(device, "vkGetSemaphoreCounterValue")); + fp_vkGetSemaphoreCounterValue = + reinterpret_cast(procAddr(device, "vkGetSemaphoreCounterValue")); #endif #if (defined(VK_VERSION_1_2)) fp_vkWaitSemaphores = reinterpret_cast(procAddr(device, "vkWaitSemaphores")); @@ -1878,127 +2561,170 @@ struct DispatchTable { fp_vkSignalSemaphore = reinterpret_cast(procAddr(device, "vkSignalSemaphore")); #endif #if (defined(VK_ANDROID_external_memory_android_hardware_buffer)) - fp_vkGetAndroidHardwareBufferPropertiesANDROID = reinterpret_cast(procAddr(device, "vkGetAndroidHardwareBufferPropertiesANDROID")); + fp_vkGetAndroidHardwareBufferPropertiesANDROID = + reinterpret_cast( + procAddr(device, "vkGetAndroidHardwareBufferPropertiesANDROID")); #endif #if (defined(VK_ANDROID_external_memory_android_hardware_buffer)) - fp_vkGetMemoryAndroidHardwareBufferANDROID = reinterpret_cast(procAddr(device, "vkGetMemoryAndroidHardwareBufferANDROID")); + fp_vkGetMemoryAndroidHardwareBufferANDROID = reinterpret_cast( + procAddr(device, "vkGetMemoryAndroidHardwareBufferANDROID")); #endif #if (defined(VK_VERSION_1_2)) - fp_vkCmdDrawIndirectCount = reinterpret_cast(procAddr(device, "vkCmdDrawIndirectCount")); + fp_vkCmdDrawIndirectCount = + reinterpret_cast(procAddr(device, "vkCmdDrawIndirectCount")); #endif #if (defined(VK_VERSION_1_2)) - fp_vkCmdDrawIndexedIndirectCount = reinterpret_cast(procAddr(device, "vkCmdDrawIndexedIndirectCount")); + fp_vkCmdDrawIndexedIndirectCount = + reinterpret_cast(procAddr(device, "vkCmdDrawIndexedIndirectCount")); #endif #if (defined(VK_NV_device_diagnostic_checkpoints)) fp_vkCmdSetCheckpointNV = reinterpret_cast(procAddr(device, "vkCmdSetCheckpointNV")); #endif #if (defined(VK_NV_device_diagnostic_checkpoints)) - fp_vkGetQueueCheckpointDataNV = reinterpret_cast(procAddr(device, "vkGetQueueCheckpointDataNV")); + fp_vkGetQueueCheckpointDataNV = + reinterpret_cast(procAddr(device, "vkGetQueueCheckpointDataNV")); #endif #if (defined(VK_EXT_transform_feedback)) - fp_vkCmdBindTransformFeedbackBuffersEXT = reinterpret_cast(procAddr(device, "vkCmdBindTransformFeedbackBuffersEXT")); + fp_vkCmdBindTransformFeedbackBuffersEXT = reinterpret_cast( + procAddr(device, "vkCmdBindTransformFeedbackBuffersEXT")); #endif #if (defined(VK_EXT_transform_feedback)) - fp_vkCmdBeginTransformFeedbackEXT = reinterpret_cast(procAddr(device, "vkCmdBeginTransformFeedbackEXT")); + fp_vkCmdBeginTransformFeedbackEXT = + reinterpret_cast(procAddr(device, "vkCmdBeginTransformFeedbackEXT")); #endif #if (defined(VK_EXT_transform_feedback)) - fp_vkCmdEndTransformFeedbackEXT = reinterpret_cast(procAddr(device, "vkCmdEndTransformFeedbackEXT")); + fp_vkCmdEndTransformFeedbackEXT = + reinterpret_cast(procAddr(device, "vkCmdEndTransformFeedbackEXT")); #endif #if (defined(VK_EXT_transform_feedback)) - fp_vkCmdBeginQueryIndexedEXT = reinterpret_cast(procAddr(device, "vkCmdBeginQueryIndexedEXT")); + fp_vkCmdBeginQueryIndexedEXT = + reinterpret_cast(procAddr(device, "vkCmdBeginQueryIndexedEXT")); #endif #if (defined(VK_EXT_transform_feedback)) - fp_vkCmdEndQueryIndexedEXT = reinterpret_cast(procAddr(device, "vkCmdEndQueryIndexedEXT")); + fp_vkCmdEndQueryIndexedEXT = + reinterpret_cast(procAddr(device, "vkCmdEndQueryIndexedEXT")); #endif #if (defined(VK_EXT_transform_feedback)) - fp_vkCmdDrawIndirectByteCountEXT = reinterpret_cast(procAddr(device, "vkCmdDrawIndirectByteCountEXT")); + fp_vkCmdDrawIndirectByteCountEXT = + reinterpret_cast(procAddr(device, "vkCmdDrawIndirectByteCountEXT")); #endif #if (defined(VK_NV_scissor_exclusive)) - fp_vkCmdSetExclusiveScissorNV = reinterpret_cast(procAddr(device, "vkCmdSetExclusiveScissorNV")); + fp_vkCmdSetExclusiveScissorNV = + reinterpret_cast(procAddr(device, "vkCmdSetExclusiveScissorNV")); #endif #if ((defined(VK_NV_scissor_exclusive))) && VK_HEADER_VERSION >= 241 - fp_vkCmdSetExclusiveScissorEnableNV = reinterpret_cast(procAddr(device, "vkCmdSetExclusiveScissorEnableNV")); + fp_vkCmdSetExclusiveScissorEnableNV = reinterpret_cast( + procAddr(device, "vkCmdSetExclusiveScissorEnableNV")); #endif #if (defined(VK_NV_shading_rate_image)) - fp_vkCmdBindShadingRateImageNV = reinterpret_cast(procAddr(device, "vkCmdBindShadingRateImageNV")); + fp_vkCmdBindShadingRateImageNV = + reinterpret_cast(procAddr(device, "vkCmdBindShadingRateImageNV")); #endif #if (defined(VK_NV_shading_rate_image)) - fp_vkCmdSetViewportShadingRatePaletteNV = reinterpret_cast(procAddr(device, "vkCmdSetViewportShadingRatePaletteNV")); + fp_vkCmdSetViewportShadingRatePaletteNV = reinterpret_cast( + procAddr(device, "vkCmdSetViewportShadingRatePaletteNV")); #endif #if (defined(VK_NV_shading_rate_image)) - fp_vkCmdSetCoarseSampleOrderNV = reinterpret_cast(procAddr(device, "vkCmdSetCoarseSampleOrderNV")); + fp_vkCmdSetCoarseSampleOrderNV = + reinterpret_cast(procAddr(device, "vkCmdSetCoarseSampleOrderNV")); #endif #if (defined(VK_NV_mesh_shader)) fp_vkCmdDrawMeshTasksNV = reinterpret_cast(procAddr(device, "vkCmdDrawMeshTasksNV")); #endif #if (defined(VK_NV_mesh_shader)) - fp_vkCmdDrawMeshTasksIndirectNV = reinterpret_cast(procAddr(device, "vkCmdDrawMeshTasksIndirectNV")); + fp_vkCmdDrawMeshTasksIndirectNV = + reinterpret_cast(procAddr(device, "vkCmdDrawMeshTasksIndirectNV")); #endif #if (defined(VK_NV_mesh_shader)) - fp_vkCmdDrawMeshTasksIndirectCountNV = reinterpret_cast(procAddr(device, "vkCmdDrawMeshTasksIndirectCountNV")); + fp_vkCmdDrawMeshTasksIndirectCountNV = reinterpret_cast( + procAddr(device, "vkCmdDrawMeshTasksIndirectCountNV")); #endif #if (defined(VK_EXT_mesh_shader)) - fp_vkCmdDrawMeshTasksEXT = reinterpret_cast(procAddr(device, "vkCmdDrawMeshTasksEXT")); + fp_vkCmdDrawMeshTasksEXT = + reinterpret_cast(procAddr(device, "vkCmdDrawMeshTasksEXT")); #endif #if (defined(VK_EXT_mesh_shader)) - fp_vkCmdDrawMeshTasksIndirectEXT = reinterpret_cast(procAddr(device, "vkCmdDrawMeshTasksIndirectEXT")); + fp_vkCmdDrawMeshTasksIndirectEXT = + reinterpret_cast(procAddr(device, "vkCmdDrawMeshTasksIndirectEXT")); #endif #if (defined(VK_EXT_mesh_shader)) - fp_vkCmdDrawMeshTasksIndirectCountEXT = reinterpret_cast(procAddr(device, "vkCmdDrawMeshTasksIndirectCountEXT")); + fp_vkCmdDrawMeshTasksIndirectCountEXT = reinterpret_cast( + procAddr(device, "vkCmdDrawMeshTasksIndirectCountEXT")); #endif #if (defined(VK_NV_ray_tracing)) fp_vkCompileDeferredNV = reinterpret_cast(procAddr(device, "vkCompileDeferredNV")); #endif #if (defined(VK_NV_ray_tracing)) - fp_vkCreateAccelerationStructureNV = reinterpret_cast(procAddr(device, "vkCreateAccelerationStructureNV")); + fp_vkCreateAccelerationStructureNV = + reinterpret_cast(procAddr(device, "vkCreateAccelerationStructureNV")); #endif #if (defined(VK_HUAWEI_invocation_mask)) - fp_vkCmdBindInvocationMaskHUAWEI = reinterpret_cast(procAddr(device, "vkCmdBindInvocationMaskHUAWEI")); + fp_vkCmdBindInvocationMaskHUAWEI = + reinterpret_cast(procAddr(device, "vkCmdBindInvocationMaskHUAWEI")); #endif #if (defined(VK_KHR_acceleration_structure)) - fp_vkDestroyAccelerationStructureKHR = reinterpret_cast(procAddr(device, "vkDestroyAccelerationStructureKHR")); + fp_vkDestroyAccelerationStructureKHR = reinterpret_cast( + procAddr(device, "vkDestroyAccelerationStructureKHR")); #endif #if (defined(VK_NV_ray_tracing)) - fp_vkDestroyAccelerationStructureNV = reinterpret_cast(procAddr(device, "vkDestroyAccelerationStructureNV")); + fp_vkDestroyAccelerationStructureNV = reinterpret_cast( + procAddr(device, "vkDestroyAccelerationStructureNV")); #endif #if (defined(VK_NV_ray_tracing)) - fp_vkGetAccelerationStructureMemoryRequirementsNV = reinterpret_cast(procAddr(device, "vkGetAccelerationStructureMemoryRequirementsNV")); + fp_vkGetAccelerationStructureMemoryRequirementsNV = + reinterpret_cast( + procAddr(device, "vkGetAccelerationStructureMemoryRequirementsNV")); #endif #if (defined(VK_NV_ray_tracing)) - fp_vkBindAccelerationStructureMemoryNV = reinterpret_cast(procAddr(device, "vkBindAccelerationStructureMemoryNV")); + fp_vkBindAccelerationStructureMemoryNV = reinterpret_cast( + procAddr(device, "vkBindAccelerationStructureMemoryNV")); #endif #if (defined(VK_NV_ray_tracing)) - fp_vkCmdCopyAccelerationStructureNV = reinterpret_cast(procAddr(device, "vkCmdCopyAccelerationStructureNV")); + fp_vkCmdCopyAccelerationStructureNV = reinterpret_cast( + procAddr(device, "vkCmdCopyAccelerationStructureNV")); #endif #if (defined(VK_KHR_acceleration_structure)) - fp_vkCmdCopyAccelerationStructureKHR = reinterpret_cast(procAddr(device, "vkCmdCopyAccelerationStructureKHR")); + fp_vkCmdCopyAccelerationStructureKHR = reinterpret_cast( + procAddr(device, "vkCmdCopyAccelerationStructureKHR")); #endif #if (defined(VK_KHR_acceleration_structure)) - fp_vkCopyAccelerationStructureKHR = reinterpret_cast(procAddr(device, "vkCopyAccelerationStructureKHR")); + fp_vkCopyAccelerationStructureKHR = + reinterpret_cast(procAddr(device, "vkCopyAccelerationStructureKHR")); #endif #if (defined(VK_KHR_acceleration_structure)) - fp_vkCmdCopyAccelerationStructureToMemoryKHR = reinterpret_cast(procAddr(device, "vkCmdCopyAccelerationStructureToMemoryKHR")); + fp_vkCmdCopyAccelerationStructureToMemoryKHR = reinterpret_cast( + procAddr(device, "vkCmdCopyAccelerationStructureToMemoryKHR")); #endif #if (defined(VK_KHR_acceleration_structure)) - fp_vkCopyAccelerationStructureToMemoryKHR = reinterpret_cast(procAddr(device, "vkCopyAccelerationStructureToMemoryKHR")); + fp_vkCopyAccelerationStructureToMemoryKHR = reinterpret_cast( + procAddr(device, "vkCopyAccelerationStructureToMemoryKHR")); #endif #if (defined(VK_KHR_acceleration_structure)) - fp_vkCmdCopyMemoryToAccelerationStructureKHR = reinterpret_cast(procAddr(device, "vkCmdCopyMemoryToAccelerationStructureKHR")); + fp_vkCmdCopyMemoryToAccelerationStructureKHR = reinterpret_cast( + procAddr(device, "vkCmdCopyMemoryToAccelerationStructureKHR")); #endif #if (defined(VK_KHR_acceleration_structure)) - fp_vkCopyMemoryToAccelerationStructureKHR = reinterpret_cast(procAddr(device, "vkCopyMemoryToAccelerationStructureKHR")); + fp_vkCopyMemoryToAccelerationStructureKHR = reinterpret_cast( + procAddr(device, "vkCopyMemoryToAccelerationStructureKHR")); #endif #if (defined(VK_KHR_acceleration_structure)) - fp_vkCmdWriteAccelerationStructuresPropertiesKHR = reinterpret_cast(procAddr(device, "vkCmdWriteAccelerationStructuresPropertiesKHR")); + fp_vkCmdWriteAccelerationStructuresPropertiesKHR = + reinterpret_cast( + procAddr(device, "vkCmdWriteAccelerationStructuresPropertiesKHR")); #endif #if (defined(VK_NV_ray_tracing)) - fp_vkCmdWriteAccelerationStructuresPropertiesNV = reinterpret_cast(procAddr(device, "vkCmdWriteAccelerationStructuresPropertiesNV")); + fp_vkCmdWriteAccelerationStructuresPropertiesNV = + reinterpret_cast( + procAddr(device, "vkCmdWriteAccelerationStructuresPropertiesNV")); #endif #if (defined(VK_NV_ray_tracing)) - fp_vkCmdBuildAccelerationStructureNV = reinterpret_cast(procAddr(device, "vkCmdBuildAccelerationStructureNV")); + fp_vkCmdBuildAccelerationStructureNV = reinterpret_cast( + procAddr(device, "vkCmdBuildAccelerationStructureNV")); #endif #if (defined(VK_KHR_acceleration_structure)) - fp_vkWriteAccelerationStructuresPropertiesKHR = reinterpret_cast(procAddr(device, "vkWriteAccelerationStructuresPropertiesKHR")); + fp_vkWriteAccelerationStructuresPropertiesKHR = + reinterpret_cast( + procAddr(device, "vkWriteAccelerationStructuresPropertiesKHR")); #endif #if (defined(VK_KHR_ray_tracing_pipeline)) fp_vkCmdTraceRaysKHR = reinterpret_cast(procAddr(device, "vkCmdTraceRaysKHR")); @@ -2007,139 +2733,188 @@ struct DispatchTable { fp_vkCmdTraceRaysNV = reinterpret_cast(procAddr(device, "vkCmdTraceRaysNV")); #endif #if (defined(VK_KHR_ray_tracing_pipeline)) - fp_vkGetRayTracingShaderGroupHandlesKHR = reinterpret_cast(procAddr(device, "vkGetRayTracingShaderGroupHandlesKHR")); + fp_vkGetRayTracingShaderGroupHandlesKHR = reinterpret_cast( + procAddr(device, "vkGetRayTracingShaderGroupHandlesKHR")); #endif #if (defined(VK_KHR_ray_tracing_pipeline)) - fp_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = reinterpret_cast(procAddr(device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR")); + fp_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = + reinterpret_cast( + procAddr(device, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR")); #endif #if (defined(VK_NV_ray_tracing)) - fp_vkGetAccelerationStructureHandleNV = reinterpret_cast(procAddr(device, "vkGetAccelerationStructureHandleNV")); + fp_vkGetAccelerationStructureHandleNV = reinterpret_cast( + procAddr(device, "vkGetAccelerationStructureHandleNV")); #endif #if (defined(VK_NV_ray_tracing)) - fp_vkCreateRayTracingPipelinesNV = reinterpret_cast(procAddr(device, "vkCreateRayTracingPipelinesNV")); + fp_vkCreateRayTracingPipelinesNV = + reinterpret_cast(procAddr(device, "vkCreateRayTracingPipelinesNV")); #endif #if (defined(VK_KHR_ray_tracing_pipeline)) - fp_vkCreateRayTracingPipelinesKHR = reinterpret_cast(procAddr(device, "vkCreateRayTracingPipelinesKHR")); + fp_vkCreateRayTracingPipelinesKHR = + reinterpret_cast(procAddr(device, "vkCreateRayTracingPipelinesKHR")); #endif #if (defined(VK_KHR_ray_tracing_pipeline)) - fp_vkCmdTraceRaysIndirectKHR = reinterpret_cast(procAddr(device, "vkCmdTraceRaysIndirectKHR")); + fp_vkCmdTraceRaysIndirectKHR = + reinterpret_cast(procAddr(device, "vkCmdTraceRaysIndirectKHR")); #endif #if (defined(VK_KHR_ray_tracing_maintenance1)) - fp_vkCmdTraceRaysIndirect2KHR = reinterpret_cast(procAddr(device, "vkCmdTraceRaysIndirect2KHR")); + fp_vkCmdTraceRaysIndirect2KHR = + reinterpret_cast(procAddr(device, "vkCmdTraceRaysIndirect2KHR")); #endif #if (defined(VK_KHR_acceleration_structure)) - fp_vkGetDeviceAccelerationStructureCompatibilityKHR = reinterpret_cast(procAddr(device, "vkGetDeviceAccelerationStructureCompatibilityKHR")); + fp_vkGetDeviceAccelerationStructureCompatibilityKHR = + reinterpret_cast( + procAddr(device, "vkGetDeviceAccelerationStructureCompatibilityKHR")); #endif #if (defined(VK_KHR_ray_tracing_pipeline)) - fp_vkGetRayTracingShaderGroupStackSizeKHR = reinterpret_cast(procAddr(device, "vkGetRayTracingShaderGroupStackSizeKHR")); + fp_vkGetRayTracingShaderGroupStackSizeKHR = reinterpret_cast( + procAddr(device, "vkGetRayTracingShaderGroupStackSizeKHR")); #endif #if (defined(VK_KHR_ray_tracing_pipeline)) - fp_vkCmdSetRayTracingPipelineStackSizeKHR = reinterpret_cast(procAddr(device, "vkCmdSetRayTracingPipelineStackSizeKHR")); + fp_vkCmdSetRayTracingPipelineStackSizeKHR = reinterpret_cast( + procAddr(device, "vkCmdSetRayTracingPipelineStackSizeKHR")); #endif #if (defined(VK_EXT_full_screen_exclusive)) - fp_vkGetDeviceGroupSurfacePresentModes2EXT = reinterpret_cast(procAddr(device, "vkGetDeviceGroupSurfacePresentModes2EXT")); + fp_vkGetDeviceGroupSurfacePresentModes2EXT = reinterpret_cast( + procAddr(device, "vkGetDeviceGroupSurfacePresentModes2EXT")); #endif #if (defined(VK_EXT_full_screen_exclusive)) - fp_vkAcquireFullScreenExclusiveModeEXT = reinterpret_cast(procAddr(device, "vkAcquireFullScreenExclusiveModeEXT")); + fp_vkAcquireFullScreenExclusiveModeEXT = reinterpret_cast( + procAddr(device, "vkAcquireFullScreenExclusiveModeEXT")); #endif #if (defined(VK_EXT_full_screen_exclusive)) - fp_vkReleaseFullScreenExclusiveModeEXT = reinterpret_cast(procAddr(device, "vkReleaseFullScreenExclusiveModeEXT")); + fp_vkReleaseFullScreenExclusiveModeEXT = reinterpret_cast( + procAddr(device, "vkReleaseFullScreenExclusiveModeEXT")); #endif #if (defined(VK_KHR_performance_query)) - fp_vkAcquireProfilingLockKHR = reinterpret_cast(procAddr(device, "vkAcquireProfilingLockKHR")); + fp_vkAcquireProfilingLockKHR = + reinterpret_cast(procAddr(device, "vkAcquireProfilingLockKHR")); #endif #if (defined(VK_KHR_performance_query)) - fp_vkReleaseProfilingLockKHR = reinterpret_cast(procAddr(device, "vkReleaseProfilingLockKHR")); + fp_vkReleaseProfilingLockKHR = + reinterpret_cast(procAddr(device, "vkReleaseProfilingLockKHR")); #endif #if (defined(VK_EXT_image_drm_format_modifier)) - fp_vkGetImageDrmFormatModifierPropertiesEXT = reinterpret_cast(procAddr(device, "vkGetImageDrmFormatModifierPropertiesEXT")); + fp_vkGetImageDrmFormatModifierPropertiesEXT = reinterpret_cast( + procAddr(device, "vkGetImageDrmFormatModifierPropertiesEXT")); #endif #if (defined(VK_VERSION_1_2)) - fp_vkGetBufferOpaqueCaptureAddress = reinterpret_cast(procAddr(device, "vkGetBufferOpaqueCaptureAddress")); + fp_vkGetBufferOpaqueCaptureAddress = + reinterpret_cast(procAddr(device, "vkGetBufferOpaqueCaptureAddress")); #endif #if (defined(VK_VERSION_1_2)) - fp_vkGetBufferDeviceAddress = reinterpret_cast(procAddr(device, "vkGetBufferDeviceAddress")); + fp_vkGetBufferDeviceAddress = + reinterpret_cast(procAddr(device, "vkGetBufferDeviceAddress")); #endif #if (defined(VK_INTEL_performance_query)) - fp_vkInitializePerformanceApiINTEL = reinterpret_cast(procAddr(device, "vkInitializePerformanceApiINTEL")); + fp_vkInitializePerformanceApiINTEL = + reinterpret_cast(procAddr(device, "vkInitializePerformanceApiINTEL")); #endif #if (defined(VK_INTEL_performance_query)) - fp_vkUninitializePerformanceApiINTEL = reinterpret_cast(procAddr(device, "vkUninitializePerformanceApiINTEL")); + fp_vkUninitializePerformanceApiINTEL = reinterpret_cast( + procAddr(device, "vkUninitializePerformanceApiINTEL")); #endif #if (defined(VK_INTEL_performance_query)) - fp_vkCmdSetPerformanceMarkerINTEL = reinterpret_cast(procAddr(device, "vkCmdSetPerformanceMarkerINTEL")); + fp_vkCmdSetPerformanceMarkerINTEL = + reinterpret_cast(procAddr(device, "vkCmdSetPerformanceMarkerINTEL")); #endif #if (defined(VK_INTEL_performance_query)) - fp_vkCmdSetPerformanceStreamMarkerINTEL = reinterpret_cast(procAddr(device, "vkCmdSetPerformanceStreamMarkerINTEL")); + fp_vkCmdSetPerformanceStreamMarkerINTEL = reinterpret_cast( + procAddr(device, "vkCmdSetPerformanceStreamMarkerINTEL")); #endif #if (defined(VK_INTEL_performance_query)) - fp_vkCmdSetPerformanceOverrideINTEL = reinterpret_cast(procAddr(device, "vkCmdSetPerformanceOverrideINTEL")); + fp_vkCmdSetPerformanceOverrideINTEL = reinterpret_cast( + procAddr(device, "vkCmdSetPerformanceOverrideINTEL")); #endif #if (defined(VK_INTEL_performance_query)) - fp_vkAcquirePerformanceConfigurationINTEL = reinterpret_cast(procAddr(device, "vkAcquirePerformanceConfigurationINTEL")); + fp_vkAcquirePerformanceConfigurationINTEL = reinterpret_cast( + procAddr(device, "vkAcquirePerformanceConfigurationINTEL")); #endif #if (defined(VK_INTEL_performance_query)) - fp_vkReleasePerformanceConfigurationINTEL = reinterpret_cast(procAddr(device, "vkReleasePerformanceConfigurationINTEL")); + fp_vkReleasePerformanceConfigurationINTEL = reinterpret_cast( + procAddr(device, "vkReleasePerformanceConfigurationINTEL")); #endif #if (defined(VK_INTEL_performance_query)) - fp_vkQueueSetPerformanceConfigurationINTEL = reinterpret_cast(procAddr(device, "vkQueueSetPerformanceConfigurationINTEL")); + fp_vkQueueSetPerformanceConfigurationINTEL = reinterpret_cast( + procAddr(device, "vkQueueSetPerformanceConfigurationINTEL")); #endif #if (defined(VK_INTEL_performance_query)) - fp_vkGetPerformanceParameterINTEL = reinterpret_cast(procAddr(device, "vkGetPerformanceParameterINTEL")); + fp_vkGetPerformanceParameterINTEL = + reinterpret_cast(procAddr(device, "vkGetPerformanceParameterINTEL")); #endif #if (defined(VK_VERSION_1_2)) - fp_vkGetDeviceMemoryOpaqueCaptureAddress = reinterpret_cast(procAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddress")); + fp_vkGetDeviceMemoryOpaqueCaptureAddress = reinterpret_cast( + procAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddress")); #endif #if (defined(VK_KHR_pipeline_executable_properties)) - fp_vkGetPipelineExecutablePropertiesKHR = reinterpret_cast(procAddr(device, "vkGetPipelineExecutablePropertiesKHR")); + fp_vkGetPipelineExecutablePropertiesKHR = reinterpret_cast( + procAddr(device, "vkGetPipelineExecutablePropertiesKHR")); #endif #if (defined(VK_KHR_pipeline_executable_properties)) - fp_vkGetPipelineExecutableStatisticsKHR = reinterpret_cast(procAddr(device, "vkGetPipelineExecutableStatisticsKHR")); + fp_vkGetPipelineExecutableStatisticsKHR = reinterpret_cast( + procAddr(device, "vkGetPipelineExecutableStatisticsKHR")); #endif #if (defined(VK_KHR_pipeline_executable_properties)) - fp_vkGetPipelineExecutableInternalRepresentationsKHR = reinterpret_cast(procAddr(device, "vkGetPipelineExecutableInternalRepresentationsKHR")); + fp_vkGetPipelineExecutableInternalRepresentationsKHR = + reinterpret_cast( + procAddr(device, "vkGetPipelineExecutableInternalRepresentationsKHR")); #endif #if (defined(VK_KHR_line_rasterization)) - fp_vkCmdSetLineStippleKHR = reinterpret_cast(procAddr(device, "vkCmdSetLineStippleKHR")); + fp_vkCmdSetLineStippleKHR = + reinterpret_cast(procAddr(device, "vkCmdSetLineStippleKHR")); #endif #if (defined(VKSC_VERSION_1_0)) fp_vkGetFaultData = reinterpret_cast(procAddr(device, "vkGetFaultData")); #endif #if (defined(VK_KHR_acceleration_structure)) - fp_vkCreateAccelerationStructureKHR = reinterpret_cast(procAddr(device, "vkCreateAccelerationStructureKHR")); + fp_vkCreateAccelerationStructureKHR = reinterpret_cast( + procAddr(device, "vkCreateAccelerationStructureKHR")); #endif #if (defined(VK_KHR_acceleration_structure)) - fp_vkCmdBuildAccelerationStructuresKHR = reinterpret_cast(procAddr(device, "vkCmdBuildAccelerationStructuresKHR")); + fp_vkCmdBuildAccelerationStructuresKHR = reinterpret_cast( + procAddr(device, "vkCmdBuildAccelerationStructuresKHR")); #endif #if (defined(VK_KHR_acceleration_structure)) - fp_vkCmdBuildAccelerationStructuresIndirectKHR = reinterpret_cast(procAddr(device, "vkCmdBuildAccelerationStructuresIndirectKHR")); + fp_vkCmdBuildAccelerationStructuresIndirectKHR = + reinterpret_cast( + procAddr(device, "vkCmdBuildAccelerationStructuresIndirectKHR")); #endif #if (defined(VK_KHR_acceleration_structure)) - fp_vkBuildAccelerationStructuresKHR = reinterpret_cast(procAddr(device, "vkBuildAccelerationStructuresKHR")); + fp_vkBuildAccelerationStructuresKHR = reinterpret_cast( + procAddr(device, "vkBuildAccelerationStructuresKHR")); #endif #if (defined(VK_KHR_acceleration_structure)) - fp_vkGetAccelerationStructureDeviceAddressKHR = reinterpret_cast(procAddr(device, "vkGetAccelerationStructureDeviceAddressKHR")); + fp_vkGetAccelerationStructureDeviceAddressKHR = + reinterpret_cast( + procAddr(device, "vkGetAccelerationStructureDeviceAddressKHR")); #endif #if (defined(VK_KHR_deferred_host_operations)) - fp_vkCreateDeferredOperationKHR = reinterpret_cast(procAddr(device, "vkCreateDeferredOperationKHR")); + fp_vkCreateDeferredOperationKHR = + reinterpret_cast(procAddr(device, "vkCreateDeferredOperationKHR")); #endif #if (defined(VK_KHR_deferred_host_operations)) - fp_vkDestroyDeferredOperationKHR = reinterpret_cast(procAddr(device, "vkDestroyDeferredOperationKHR")); + fp_vkDestroyDeferredOperationKHR = + reinterpret_cast(procAddr(device, "vkDestroyDeferredOperationKHR")); #endif #if (defined(VK_KHR_deferred_host_operations)) - fp_vkGetDeferredOperationMaxConcurrencyKHR = reinterpret_cast(procAddr(device, "vkGetDeferredOperationMaxConcurrencyKHR")); + fp_vkGetDeferredOperationMaxConcurrencyKHR = reinterpret_cast( + procAddr(device, "vkGetDeferredOperationMaxConcurrencyKHR")); #endif #if (defined(VK_KHR_deferred_host_operations)) - fp_vkGetDeferredOperationResultKHR = reinterpret_cast(procAddr(device, "vkGetDeferredOperationResultKHR")); + fp_vkGetDeferredOperationResultKHR = + reinterpret_cast(procAddr(device, "vkGetDeferredOperationResultKHR")); #endif #if (defined(VK_KHR_deferred_host_operations)) - fp_vkDeferredOperationJoinKHR = reinterpret_cast(procAddr(device, "vkDeferredOperationJoinKHR")); + fp_vkDeferredOperationJoinKHR = + reinterpret_cast(procAddr(device, "vkDeferredOperationJoinKHR")); #endif #if (defined(VK_NV_device_generated_commands_compute)) - fp_vkGetPipelineIndirectMemoryRequirementsNV = reinterpret_cast(procAddr(device, "vkGetPipelineIndirectMemoryRequirementsNV")); + fp_vkGetPipelineIndirectMemoryRequirementsNV = reinterpret_cast( + procAddr(device, "vkGetPipelineIndirectMemoryRequirementsNV")); #endif #if (defined(VK_NV_device_generated_commands_compute)) - fp_vkGetPipelineIndirectDeviceAddressNV = reinterpret_cast(procAddr(device, "vkGetPipelineIndirectDeviceAddressNV")); + fp_vkGetPipelineIndirectDeviceAddressNV = reinterpret_cast( + procAddr(device, "vkGetPipelineIndirectDeviceAddressNV")); #endif #if (defined(VK_AMD_anti_lag)) fp_vkAntiLagUpdateAMD = reinterpret_cast(procAddr(device, "vkAntiLagUpdateAMD")); @@ -2151,151 +2926,200 @@ struct DispatchTable { fp_vkCmdSetFrontFace = reinterpret_cast(procAddr(device, "vkCmdSetFrontFace")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkCmdSetPrimitiveTopology = reinterpret_cast(procAddr(device, "vkCmdSetPrimitiveTopology")); + fp_vkCmdSetPrimitiveTopology = + reinterpret_cast(procAddr(device, "vkCmdSetPrimitiveTopology")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkCmdSetViewportWithCount = reinterpret_cast(procAddr(device, "vkCmdSetViewportWithCount")); + fp_vkCmdSetViewportWithCount = + reinterpret_cast(procAddr(device, "vkCmdSetViewportWithCount")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkCmdSetScissorWithCount = reinterpret_cast(procAddr(device, "vkCmdSetScissorWithCount")); + fp_vkCmdSetScissorWithCount = + reinterpret_cast(procAddr(device, "vkCmdSetScissorWithCount")); #endif #if (defined(VK_KHR_maintenance5)) - fp_vkCmdBindIndexBuffer2KHR = reinterpret_cast(procAddr(device, "vkCmdBindIndexBuffer2KHR")); + fp_vkCmdBindIndexBuffer2KHR = + reinterpret_cast(procAddr(device, "vkCmdBindIndexBuffer2KHR")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkCmdBindVertexBuffers2 = reinterpret_cast(procAddr(device, "vkCmdBindVertexBuffers2")); + fp_vkCmdBindVertexBuffers2 = + reinterpret_cast(procAddr(device, "vkCmdBindVertexBuffers2")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkCmdSetDepthTestEnable = reinterpret_cast(procAddr(device, "vkCmdSetDepthTestEnable")); + fp_vkCmdSetDepthTestEnable = + reinterpret_cast(procAddr(device, "vkCmdSetDepthTestEnable")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkCmdSetDepthWriteEnable = reinterpret_cast(procAddr(device, "vkCmdSetDepthWriteEnable")); + fp_vkCmdSetDepthWriteEnable = + reinterpret_cast(procAddr(device, "vkCmdSetDepthWriteEnable")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkCmdSetDepthCompareOp = reinterpret_cast(procAddr(device, "vkCmdSetDepthCompareOp")); + fp_vkCmdSetDepthCompareOp = + reinterpret_cast(procAddr(device, "vkCmdSetDepthCompareOp")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkCmdSetDepthBoundsTestEnable = reinterpret_cast(procAddr(device, "vkCmdSetDepthBoundsTestEnable")); + fp_vkCmdSetDepthBoundsTestEnable = + reinterpret_cast(procAddr(device, "vkCmdSetDepthBoundsTestEnable")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkCmdSetStencilTestEnable = reinterpret_cast(procAddr(device, "vkCmdSetStencilTestEnable")); + fp_vkCmdSetStencilTestEnable = + reinterpret_cast(procAddr(device, "vkCmdSetStencilTestEnable")); #endif #if (defined(VK_VERSION_1_3)) fp_vkCmdSetStencilOp = reinterpret_cast(procAddr(device, "vkCmdSetStencilOp")); #endif #if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetPatchControlPointsEXT = reinterpret_cast(procAddr(device, "vkCmdSetPatchControlPointsEXT")); + fp_vkCmdSetPatchControlPointsEXT = + reinterpret_cast(procAddr(device, "vkCmdSetPatchControlPointsEXT")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkCmdSetRasterizerDiscardEnable = reinterpret_cast(procAddr(device, "vkCmdSetRasterizerDiscardEnable")); + fp_vkCmdSetRasterizerDiscardEnable = + reinterpret_cast(procAddr(device, "vkCmdSetRasterizerDiscardEnable")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkCmdSetDepthBiasEnable = reinterpret_cast(procAddr(device, "vkCmdSetDepthBiasEnable")); + fp_vkCmdSetDepthBiasEnable = + reinterpret_cast(procAddr(device, "vkCmdSetDepthBiasEnable")); #endif #if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) fp_vkCmdSetLogicOpEXT = reinterpret_cast(procAddr(device, "vkCmdSetLogicOpEXT")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkCmdSetPrimitiveRestartEnable = reinterpret_cast(procAddr(device, "vkCmdSetPrimitiveRestartEnable")); + fp_vkCmdSetPrimitiveRestartEnable = + reinterpret_cast(procAddr(device, "vkCmdSetPrimitiveRestartEnable")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetTessellationDomainOriginEXT = reinterpret_cast(procAddr(device, "vkCmdSetTessellationDomainOriginEXT")); + fp_vkCmdSetTessellationDomainOriginEXT = reinterpret_cast( + procAddr(device, "vkCmdSetTessellationDomainOriginEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetDepthClampEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetDepthClampEnableEXT")); + fp_vkCmdSetDepthClampEnableEXT = + reinterpret_cast(procAddr(device, "vkCmdSetDepthClampEnableEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetPolygonModeEXT = reinterpret_cast(procAddr(device, "vkCmdSetPolygonModeEXT")); + fp_vkCmdSetPolygonModeEXT = + reinterpret_cast(procAddr(device, "vkCmdSetPolygonModeEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetRasterizationSamplesEXT = reinterpret_cast(procAddr(device, "vkCmdSetRasterizationSamplesEXT")); + fp_vkCmdSetRasterizationSamplesEXT = + reinterpret_cast(procAddr(device, "vkCmdSetRasterizationSamplesEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetSampleMaskEXT = reinterpret_cast(procAddr(device, "vkCmdSetSampleMaskEXT")); + fp_vkCmdSetSampleMaskEXT = + reinterpret_cast(procAddr(device, "vkCmdSetSampleMaskEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetAlphaToCoverageEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetAlphaToCoverageEnableEXT")); + fp_vkCmdSetAlphaToCoverageEnableEXT = reinterpret_cast( + procAddr(device, "vkCmdSetAlphaToCoverageEnableEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetAlphaToOneEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetAlphaToOneEnableEXT")); + fp_vkCmdSetAlphaToOneEnableEXT = + reinterpret_cast(procAddr(device, "vkCmdSetAlphaToOneEnableEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetLogicOpEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetLogicOpEnableEXT")); + fp_vkCmdSetLogicOpEnableEXT = + reinterpret_cast(procAddr(device, "vkCmdSetLogicOpEnableEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetColorBlendEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetColorBlendEnableEXT")); + fp_vkCmdSetColorBlendEnableEXT = + reinterpret_cast(procAddr(device, "vkCmdSetColorBlendEnableEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetColorBlendEquationEXT = reinterpret_cast(procAddr(device, "vkCmdSetColorBlendEquationEXT")); + fp_vkCmdSetColorBlendEquationEXT = + reinterpret_cast(procAddr(device, "vkCmdSetColorBlendEquationEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetColorWriteMaskEXT = reinterpret_cast(procAddr(device, "vkCmdSetColorWriteMaskEXT")); + fp_vkCmdSetColorWriteMaskEXT = + reinterpret_cast(procAddr(device, "vkCmdSetColorWriteMaskEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetRasterizationStreamEXT = reinterpret_cast(procAddr(device, "vkCmdSetRasterizationStreamEXT")); + fp_vkCmdSetRasterizationStreamEXT = + reinterpret_cast(procAddr(device, "vkCmdSetRasterizationStreamEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetConservativeRasterizationModeEXT = reinterpret_cast(procAddr(device, "vkCmdSetConservativeRasterizationModeEXT")); + fp_vkCmdSetConservativeRasterizationModeEXT = reinterpret_cast( + procAddr(device, "vkCmdSetConservativeRasterizationModeEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetExtraPrimitiveOverestimationSizeEXT = reinterpret_cast(procAddr(device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT")); + fp_vkCmdSetExtraPrimitiveOverestimationSizeEXT = + reinterpret_cast( + procAddr(device, "vkCmdSetExtraPrimitiveOverestimationSizeEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetDepthClipEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetDepthClipEnableEXT")); + fp_vkCmdSetDepthClipEnableEXT = + reinterpret_cast(procAddr(device, "vkCmdSetDepthClipEnableEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetSampleLocationsEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetSampleLocationsEnableEXT")); + fp_vkCmdSetSampleLocationsEnableEXT = reinterpret_cast( + procAddr(device, "vkCmdSetSampleLocationsEnableEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetColorBlendAdvancedEXT = reinterpret_cast(procAddr(device, "vkCmdSetColorBlendAdvancedEXT")); + fp_vkCmdSetColorBlendAdvancedEXT = + reinterpret_cast(procAddr(device, "vkCmdSetColorBlendAdvancedEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetProvokingVertexModeEXT = reinterpret_cast(procAddr(device, "vkCmdSetProvokingVertexModeEXT")); + fp_vkCmdSetProvokingVertexModeEXT = + reinterpret_cast(procAddr(device, "vkCmdSetProvokingVertexModeEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetLineRasterizationModeEXT = reinterpret_cast(procAddr(device, "vkCmdSetLineRasterizationModeEXT")); + fp_vkCmdSetLineRasterizationModeEXT = reinterpret_cast( + procAddr(device, "vkCmdSetLineRasterizationModeEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetLineStippleEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetLineStippleEnableEXT")); + fp_vkCmdSetLineStippleEnableEXT = + reinterpret_cast(procAddr(device, "vkCmdSetLineStippleEnableEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetDepthClipNegativeOneToOneEXT = reinterpret_cast(procAddr(device, "vkCmdSetDepthClipNegativeOneToOneEXT")); + fp_vkCmdSetDepthClipNegativeOneToOneEXT = reinterpret_cast( + procAddr(device, "vkCmdSetDepthClipNegativeOneToOneEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetViewportWScalingEnableNV = reinterpret_cast(procAddr(device, "vkCmdSetViewportWScalingEnableNV")); + fp_vkCmdSetViewportWScalingEnableNV = reinterpret_cast( + procAddr(device, "vkCmdSetViewportWScalingEnableNV")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetViewportSwizzleNV = reinterpret_cast(procAddr(device, "vkCmdSetViewportSwizzleNV")); + fp_vkCmdSetViewportSwizzleNV = + reinterpret_cast(procAddr(device, "vkCmdSetViewportSwizzleNV")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetCoverageToColorEnableNV = reinterpret_cast(procAddr(device, "vkCmdSetCoverageToColorEnableNV")); + fp_vkCmdSetCoverageToColorEnableNV = + reinterpret_cast(procAddr(device, "vkCmdSetCoverageToColorEnableNV")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetCoverageToColorLocationNV = reinterpret_cast(procAddr(device, "vkCmdSetCoverageToColorLocationNV")); + fp_vkCmdSetCoverageToColorLocationNV = reinterpret_cast( + procAddr(device, "vkCmdSetCoverageToColorLocationNV")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetCoverageModulationModeNV = reinterpret_cast(procAddr(device, "vkCmdSetCoverageModulationModeNV")); + fp_vkCmdSetCoverageModulationModeNV = reinterpret_cast( + procAddr(device, "vkCmdSetCoverageModulationModeNV")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetCoverageModulationTableEnableNV = reinterpret_cast(procAddr(device, "vkCmdSetCoverageModulationTableEnableNV")); + fp_vkCmdSetCoverageModulationTableEnableNV = reinterpret_cast( + procAddr(device, "vkCmdSetCoverageModulationTableEnableNV")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetCoverageModulationTableNV = reinterpret_cast(procAddr(device, "vkCmdSetCoverageModulationTableNV")); + fp_vkCmdSetCoverageModulationTableNV = reinterpret_cast( + procAddr(device, "vkCmdSetCoverageModulationTableNV")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetShadingRateImageEnableNV = reinterpret_cast(procAddr(device, "vkCmdSetShadingRateImageEnableNV")); + fp_vkCmdSetShadingRateImageEnableNV = reinterpret_cast( + procAddr(device, "vkCmdSetShadingRateImageEnableNV")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetCoverageReductionModeNV = reinterpret_cast(procAddr(device, "vkCmdSetCoverageReductionModeNV")); + fp_vkCmdSetCoverageReductionModeNV = + reinterpret_cast(procAddr(device, "vkCmdSetCoverageReductionModeNV")); #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetRepresentativeFragmentTestEnableNV = reinterpret_cast(procAddr(device, "vkCmdSetRepresentativeFragmentTestEnableNV")); + fp_vkCmdSetRepresentativeFragmentTestEnableNV = + reinterpret_cast( + procAddr(device, "vkCmdSetRepresentativeFragmentTestEnableNV")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkCreatePrivateDataSlot = reinterpret_cast(procAddr(device, "vkCreatePrivateDataSlot")); + fp_vkCreatePrivateDataSlot = + reinterpret_cast(procAddr(device, "vkCreatePrivateDataSlot")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkDestroyPrivateDataSlot = reinterpret_cast(procAddr(device, "vkDestroyPrivateDataSlot")); + fp_vkDestroyPrivateDataSlot = + reinterpret_cast(procAddr(device, "vkDestroyPrivateDataSlot")); #endif #if (defined(VK_VERSION_1_3)) fp_vkSetPrivateData = reinterpret_cast(procAddr(device, "vkSetPrivateData")); @@ -2313,31 +3137,39 @@ struct DispatchTable { fp_vkCmdBlitImage2 = reinterpret_cast(procAddr(device, "vkCmdBlitImage2")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkCmdCopyBufferToImage2 = reinterpret_cast(procAddr(device, "vkCmdCopyBufferToImage2")); + fp_vkCmdCopyBufferToImage2 = + reinterpret_cast(procAddr(device, "vkCmdCopyBufferToImage2")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkCmdCopyImageToBuffer2 = reinterpret_cast(procAddr(device, "vkCmdCopyImageToBuffer2")); + fp_vkCmdCopyImageToBuffer2 = + reinterpret_cast(procAddr(device, "vkCmdCopyImageToBuffer2")); #endif #if (defined(VK_VERSION_1_3)) fp_vkCmdResolveImage2 = reinterpret_cast(procAddr(device, "vkCmdResolveImage2")); #endif #if (defined(VK_KHR_object_refresh)) - fp_vkCmdRefreshObjectsKHR = reinterpret_cast(procAddr(device, "vkCmdRefreshObjectsKHR")); + fp_vkCmdRefreshObjectsKHR = + reinterpret_cast(procAddr(device, "vkCmdRefreshObjectsKHR")); #endif #if (defined(VK_KHR_fragment_shading_rate)) - fp_vkCmdSetFragmentShadingRateKHR = reinterpret_cast(procAddr(device, "vkCmdSetFragmentShadingRateKHR")); + fp_vkCmdSetFragmentShadingRateKHR = + reinterpret_cast(procAddr(device, "vkCmdSetFragmentShadingRateKHR")); #endif #if (defined(VK_NV_fragment_shading_rate_enums)) - fp_vkCmdSetFragmentShadingRateEnumNV = reinterpret_cast(procAddr(device, "vkCmdSetFragmentShadingRateEnumNV")); + fp_vkCmdSetFragmentShadingRateEnumNV = reinterpret_cast( + procAddr(device, "vkCmdSetFragmentShadingRateEnumNV")); #endif #if (defined(VK_KHR_acceleration_structure)) - fp_vkGetAccelerationStructureBuildSizesKHR = reinterpret_cast(procAddr(device, "vkGetAccelerationStructureBuildSizesKHR")); + fp_vkGetAccelerationStructureBuildSizesKHR = reinterpret_cast( + procAddr(device, "vkGetAccelerationStructureBuildSizesKHR")); #endif #if (defined(VK_EXT_vertex_input_dynamic_state)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetVertexInputEXT = reinterpret_cast(procAddr(device, "vkCmdSetVertexInputEXT")); + fp_vkCmdSetVertexInputEXT = + reinterpret_cast(procAddr(device, "vkCmdSetVertexInputEXT")); #endif #if (defined(VK_EXT_color_write_enable)) - fp_vkCmdSetColorWriteEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetColorWriteEnableEXT")); + fp_vkCmdSetColorWriteEnableEXT = + reinterpret_cast(procAddr(device, "vkCmdSetColorWriteEnableEXT")); #endif #if (defined(VK_VERSION_1_3)) fp_vkCmdSetEvent2 = reinterpret_cast(procAddr(device, "vkCmdSetEvent2")); @@ -2349,7 +3181,8 @@ struct DispatchTable { fp_vkCmdWaitEvents2 = reinterpret_cast(procAddr(device, "vkCmdWaitEvents2")); #endif #if (defined(VK_VERSION_1_3)) - fp_vkCmdPipelineBarrier2 = reinterpret_cast(procAddr(device, "vkCmdPipelineBarrier2")); + fp_vkCmdPipelineBarrier2 = + reinterpret_cast(procAddr(device, "vkCmdPipelineBarrier2")); #endif #if (defined(VK_VERSION_1_3)) fp_vkQueueSubmit2 = reinterpret_cast(procAddr(device, "vkQueueSubmit2")); @@ -2358,142 +3191,189 @@ struct DispatchTable { fp_vkCmdWriteTimestamp2 = reinterpret_cast(procAddr(device, "vkCmdWriteTimestamp2")); #endif #if (defined(VK_KHR_synchronization2)) - fp_vkCmdWriteBufferMarker2AMD = reinterpret_cast(procAddr(device, "vkCmdWriteBufferMarker2AMD")); + fp_vkCmdWriteBufferMarker2AMD = + reinterpret_cast(procAddr(device, "vkCmdWriteBufferMarker2AMD")); #endif #if (defined(VK_KHR_synchronization2)) - fp_vkGetQueueCheckpointData2NV = reinterpret_cast(procAddr(device, "vkGetQueueCheckpointData2NV")); + fp_vkGetQueueCheckpointData2NV = + reinterpret_cast(procAddr(device, "vkGetQueueCheckpointData2NV")); #endif #if (defined(VK_EXT_host_image_copy)) - fp_vkCopyMemoryToImageEXT = reinterpret_cast(procAddr(device, "vkCopyMemoryToImageEXT")); + fp_vkCopyMemoryToImageEXT = + reinterpret_cast(procAddr(device, "vkCopyMemoryToImageEXT")); #endif #if (defined(VK_EXT_host_image_copy)) - fp_vkCopyImageToMemoryEXT = reinterpret_cast(procAddr(device, "vkCopyImageToMemoryEXT")); + fp_vkCopyImageToMemoryEXT = + reinterpret_cast(procAddr(device, "vkCopyImageToMemoryEXT")); #endif #if (defined(VK_EXT_host_image_copy)) - fp_vkCopyImageToImageEXT = reinterpret_cast(procAddr(device, "vkCopyImageToImageEXT")); + fp_vkCopyImageToImageEXT = + reinterpret_cast(procAddr(device, "vkCopyImageToImageEXT")); #endif #if (defined(VK_EXT_host_image_copy)) - fp_vkTransitionImageLayoutEXT = reinterpret_cast(procAddr(device, "vkTransitionImageLayoutEXT")); + fp_vkTransitionImageLayoutEXT = + reinterpret_cast(procAddr(device, "vkTransitionImageLayoutEXT")); #endif #if (defined(VKSC_VERSION_1_0)) - fp_vkGetCommandPoolMemoryConsumption = reinterpret_cast(procAddr(device, "vkGetCommandPoolMemoryConsumption")); + fp_vkGetCommandPoolMemoryConsumption = reinterpret_cast( + procAddr(device, "vkGetCommandPoolMemoryConsumption")); #endif #if (defined(VK_KHR_video_queue)) - fp_vkCreateVideoSessionKHR = reinterpret_cast(procAddr(device, "vkCreateVideoSessionKHR")); + fp_vkCreateVideoSessionKHR = + reinterpret_cast(procAddr(device, "vkCreateVideoSessionKHR")); #endif #if (defined(VK_KHR_video_queue)) - fp_vkDestroyVideoSessionKHR = reinterpret_cast(procAddr(device, "vkDestroyVideoSessionKHR")); + fp_vkDestroyVideoSessionKHR = + reinterpret_cast(procAddr(device, "vkDestroyVideoSessionKHR")); #endif #if (defined(VK_KHR_video_queue)) - fp_vkCreateVideoSessionParametersKHR = reinterpret_cast(procAddr(device, "vkCreateVideoSessionParametersKHR")); + fp_vkCreateVideoSessionParametersKHR = reinterpret_cast( + procAddr(device, "vkCreateVideoSessionParametersKHR")); #endif #if (defined(VK_KHR_video_queue)) - fp_vkUpdateVideoSessionParametersKHR = reinterpret_cast(procAddr(device, "vkUpdateVideoSessionParametersKHR")); + fp_vkUpdateVideoSessionParametersKHR = reinterpret_cast( + procAddr(device, "vkUpdateVideoSessionParametersKHR")); #endif #if (defined(VK_KHR_video_encode_queue)) - fp_vkGetEncodedVideoSessionParametersKHR = reinterpret_cast(procAddr(device, "vkGetEncodedVideoSessionParametersKHR")); + fp_vkGetEncodedVideoSessionParametersKHR = reinterpret_cast( + procAddr(device, "vkGetEncodedVideoSessionParametersKHR")); #endif #if (defined(VK_KHR_video_queue)) - fp_vkDestroyVideoSessionParametersKHR = reinterpret_cast(procAddr(device, "vkDestroyVideoSessionParametersKHR")); + fp_vkDestroyVideoSessionParametersKHR = reinterpret_cast( + procAddr(device, "vkDestroyVideoSessionParametersKHR")); #endif #if (defined(VK_KHR_video_queue)) - fp_vkGetVideoSessionMemoryRequirementsKHR = reinterpret_cast(procAddr(device, "vkGetVideoSessionMemoryRequirementsKHR")); + fp_vkGetVideoSessionMemoryRequirementsKHR = reinterpret_cast( + procAddr(device, "vkGetVideoSessionMemoryRequirementsKHR")); #endif #if (defined(VK_KHR_video_queue)) - fp_vkBindVideoSessionMemoryKHR = reinterpret_cast(procAddr(device, "vkBindVideoSessionMemoryKHR")); + fp_vkBindVideoSessionMemoryKHR = + reinterpret_cast(procAddr(device, "vkBindVideoSessionMemoryKHR")); #endif #if (defined(VK_KHR_video_decode_queue)) fp_vkCmdDecodeVideoKHR = reinterpret_cast(procAddr(device, "vkCmdDecodeVideoKHR")); #endif #if (defined(VK_KHR_video_queue)) - fp_vkCmdBeginVideoCodingKHR = reinterpret_cast(procAddr(device, "vkCmdBeginVideoCodingKHR")); + fp_vkCmdBeginVideoCodingKHR = + reinterpret_cast(procAddr(device, "vkCmdBeginVideoCodingKHR")); #endif #if (defined(VK_KHR_video_queue)) - fp_vkCmdControlVideoCodingKHR = reinterpret_cast(procAddr(device, "vkCmdControlVideoCodingKHR")); + fp_vkCmdControlVideoCodingKHR = + reinterpret_cast(procAddr(device, "vkCmdControlVideoCodingKHR")); #endif #if (defined(VK_KHR_video_queue)) - fp_vkCmdEndVideoCodingKHR = reinterpret_cast(procAddr(device, "vkCmdEndVideoCodingKHR")); + fp_vkCmdEndVideoCodingKHR = + reinterpret_cast(procAddr(device, "vkCmdEndVideoCodingKHR")); #endif #if (defined(VK_KHR_video_encode_queue)) fp_vkCmdEncodeVideoKHR = reinterpret_cast(procAddr(device, "vkCmdEncodeVideoKHR")); #endif #if (defined(VK_NV_memory_decompression)) - fp_vkCmdDecompressMemoryNV = reinterpret_cast(procAddr(device, "vkCmdDecompressMemoryNV")); + fp_vkCmdDecompressMemoryNV = + reinterpret_cast(procAddr(device, "vkCmdDecompressMemoryNV")); #endif #if (defined(VK_NV_memory_decompression)) - fp_vkCmdDecompressMemoryIndirectCountNV = reinterpret_cast(procAddr(device, "vkCmdDecompressMemoryIndirectCountNV")); + fp_vkCmdDecompressMemoryIndirectCountNV = reinterpret_cast( + procAddr(device, "vkCmdDecompressMemoryIndirectCountNV")); #endif #if (defined(VK_EXT_descriptor_buffer)) - fp_vkGetDescriptorSetLayoutSizeEXT = reinterpret_cast(procAddr(device, "vkGetDescriptorSetLayoutSizeEXT")); + fp_vkGetDescriptorSetLayoutSizeEXT = + reinterpret_cast(procAddr(device, "vkGetDescriptorSetLayoutSizeEXT")); #endif #if (defined(VK_EXT_descriptor_buffer)) - fp_vkGetDescriptorSetLayoutBindingOffsetEXT = reinterpret_cast(procAddr(device, "vkGetDescriptorSetLayoutBindingOffsetEXT")); + fp_vkGetDescriptorSetLayoutBindingOffsetEXT = reinterpret_cast( + procAddr(device, "vkGetDescriptorSetLayoutBindingOffsetEXT")); #endif #if (defined(VK_EXT_descriptor_buffer)) fp_vkGetDescriptorEXT = reinterpret_cast(procAddr(device, "vkGetDescriptorEXT")); #endif #if (defined(VK_EXT_descriptor_buffer)) - fp_vkCmdBindDescriptorBuffersEXT = reinterpret_cast(procAddr(device, "vkCmdBindDescriptorBuffersEXT")); + fp_vkCmdBindDescriptorBuffersEXT = + reinterpret_cast(procAddr(device, "vkCmdBindDescriptorBuffersEXT")); #endif #if (defined(VK_EXT_descriptor_buffer)) - fp_vkCmdSetDescriptorBufferOffsetsEXT = reinterpret_cast(procAddr(device, "vkCmdSetDescriptorBufferOffsetsEXT")); + fp_vkCmdSetDescriptorBufferOffsetsEXT = reinterpret_cast( + procAddr(device, "vkCmdSetDescriptorBufferOffsetsEXT")); #endif #if (defined(VK_EXT_descriptor_buffer)) - fp_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = reinterpret_cast(procAddr(device, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT")); + fp_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = + reinterpret_cast( + procAddr(device, "vkCmdBindDescriptorBufferEmbeddedSamplersEXT")); #endif #if (defined(VK_EXT_descriptor_buffer)) - fp_vkGetBufferOpaqueCaptureDescriptorDataEXT = reinterpret_cast(procAddr(device, "vkGetBufferOpaqueCaptureDescriptorDataEXT")); + fp_vkGetBufferOpaqueCaptureDescriptorDataEXT = reinterpret_cast( + procAddr(device, "vkGetBufferOpaqueCaptureDescriptorDataEXT")); #endif #if (defined(VK_EXT_descriptor_buffer)) - fp_vkGetImageOpaqueCaptureDescriptorDataEXT = reinterpret_cast(procAddr(device, "vkGetImageOpaqueCaptureDescriptorDataEXT")); + fp_vkGetImageOpaqueCaptureDescriptorDataEXT = reinterpret_cast( + procAddr(device, "vkGetImageOpaqueCaptureDescriptorDataEXT")); #endif #if (defined(VK_EXT_descriptor_buffer)) - fp_vkGetImageViewOpaqueCaptureDescriptorDataEXT = reinterpret_cast(procAddr(device, "vkGetImageViewOpaqueCaptureDescriptorDataEXT")); + fp_vkGetImageViewOpaqueCaptureDescriptorDataEXT = + reinterpret_cast( + procAddr(device, "vkGetImageViewOpaqueCaptureDescriptorDataEXT")); #endif #if (defined(VK_EXT_descriptor_buffer)) - fp_vkGetSamplerOpaqueCaptureDescriptorDataEXT = reinterpret_cast(procAddr(device, "vkGetSamplerOpaqueCaptureDescriptorDataEXT")); + fp_vkGetSamplerOpaqueCaptureDescriptorDataEXT = + reinterpret_cast( + procAddr(device, "vkGetSamplerOpaqueCaptureDescriptorDataEXT")); #endif #if (defined(VK_EXT_descriptor_buffer)) - fp_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = reinterpret_cast(procAddr(device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT")); + fp_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = + reinterpret_cast( + procAddr(device, "vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT")); #endif #if (defined(VK_EXT_pageable_device_local_memory)) - fp_vkSetDeviceMemoryPriorityEXT = reinterpret_cast(procAddr(device, "vkSetDeviceMemoryPriorityEXT")); + fp_vkSetDeviceMemoryPriorityEXT = + reinterpret_cast(procAddr(device, "vkSetDeviceMemoryPriorityEXT")); #endif #if (defined(VK_KHR_present_wait)) fp_vkWaitForPresentKHR = reinterpret_cast(procAddr(device, "vkWaitForPresentKHR")); #endif #if (defined(VK_FUCHSIA_buffer_collection)) - fp_vkCreateBufferCollectionFUCHSIA = reinterpret_cast(procAddr(device, "vkCreateBufferCollectionFUCHSIA")); + fp_vkCreateBufferCollectionFUCHSIA = + reinterpret_cast(procAddr(device, "vkCreateBufferCollectionFUCHSIA")); #endif #if (defined(VK_FUCHSIA_buffer_collection)) - fp_vkSetBufferCollectionBufferConstraintsFUCHSIA = reinterpret_cast(procAddr(device, "vkSetBufferCollectionBufferConstraintsFUCHSIA")); + fp_vkSetBufferCollectionBufferConstraintsFUCHSIA = + reinterpret_cast( + procAddr(device, "vkSetBufferCollectionBufferConstraintsFUCHSIA")); #endif #if (defined(VK_FUCHSIA_buffer_collection)) - fp_vkSetBufferCollectionImageConstraintsFUCHSIA = reinterpret_cast(procAddr(device, "vkSetBufferCollectionImageConstraintsFUCHSIA")); + fp_vkSetBufferCollectionImageConstraintsFUCHSIA = + reinterpret_cast( + procAddr(device, "vkSetBufferCollectionImageConstraintsFUCHSIA")); #endif #if (defined(VK_FUCHSIA_buffer_collection)) - fp_vkDestroyBufferCollectionFUCHSIA = reinterpret_cast(procAddr(device, "vkDestroyBufferCollectionFUCHSIA")); + fp_vkDestroyBufferCollectionFUCHSIA = reinterpret_cast( + procAddr(device, "vkDestroyBufferCollectionFUCHSIA")); #endif #if (defined(VK_FUCHSIA_buffer_collection)) - fp_vkGetBufferCollectionPropertiesFUCHSIA = reinterpret_cast(procAddr(device, "vkGetBufferCollectionPropertiesFUCHSIA")); + fp_vkGetBufferCollectionPropertiesFUCHSIA = reinterpret_cast( + procAddr(device, "vkGetBufferCollectionPropertiesFUCHSIA")); #endif #if (defined(VK_NV_cuda_kernel_launch)) fp_vkCreateCudaModuleNV = reinterpret_cast(procAddr(device, "vkCreateCudaModuleNV")); #endif #if (defined(VK_NV_cuda_kernel_launch)) - fp_vkGetCudaModuleCacheNV = reinterpret_cast(procAddr(device, "vkGetCudaModuleCacheNV")); + fp_vkGetCudaModuleCacheNV = + reinterpret_cast(procAddr(device, "vkGetCudaModuleCacheNV")); #endif #if (defined(VK_NV_cuda_kernel_launch)) - fp_vkCreateCudaFunctionNV = reinterpret_cast(procAddr(device, "vkCreateCudaFunctionNV")); + fp_vkCreateCudaFunctionNV = + reinterpret_cast(procAddr(device, "vkCreateCudaFunctionNV")); #endif #if (defined(VK_NV_cuda_kernel_launch)) - fp_vkDestroyCudaModuleNV = reinterpret_cast(procAddr(device, "vkDestroyCudaModuleNV")); + fp_vkDestroyCudaModuleNV = + reinterpret_cast(procAddr(device, "vkDestroyCudaModuleNV")); #endif #if (defined(VK_NV_cuda_kernel_launch)) - fp_vkDestroyCudaFunctionNV = reinterpret_cast(procAddr(device, "vkDestroyCudaFunctionNV")); + fp_vkDestroyCudaFunctionNV = + reinterpret_cast(procAddr(device, "vkDestroyCudaFunctionNV")); #endif #if (defined(VK_NV_cuda_kernel_launch)) - fp_vkCmdCudaLaunchKernelNV = reinterpret_cast(procAddr(device, "vkCmdCudaLaunchKernelNV")); + fp_vkCmdCudaLaunchKernelNV = + reinterpret_cast(procAddr(device, "vkCmdCudaLaunchKernelNV")); #endif #if (defined(VK_VERSION_1_3)) fp_vkCmdBeginRendering = reinterpret_cast(procAddr(device, "vkCmdBeginRendering")); @@ -2502,16 +3382,20 @@ struct DispatchTable { fp_vkCmdEndRendering = reinterpret_cast(procAddr(device, "vkCmdEndRendering")); #endif #if (defined(VK_VALVE_descriptor_set_host_mapping)) - fp_vkGetDescriptorSetLayoutHostMappingInfoVALVE = reinterpret_cast(procAddr(device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE")); + fp_vkGetDescriptorSetLayoutHostMappingInfoVALVE = + reinterpret_cast( + procAddr(device, "vkGetDescriptorSetLayoutHostMappingInfoVALVE")); #endif #if (defined(VK_VALVE_descriptor_set_host_mapping)) - fp_vkGetDescriptorSetHostMappingVALVE = reinterpret_cast(procAddr(device, "vkGetDescriptorSetHostMappingVALVE")); + fp_vkGetDescriptorSetHostMappingVALVE = reinterpret_cast( + procAddr(device, "vkGetDescriptorSetHostMappingVALVE")); #endif #if (defined(VK_EXT_opacity_micromap)) fp_vkCreateMicromapEXT = reinterpret_cast(procAddr(device, "vkCreateMicromapEXT")); #endif #if (defined(VK_EXT_opacity_micromap)) - fp_vkCmdBuildMicromapsEXT = reinterpret_cast(procAddr(device, "vkCmdBuildMicromapsEXT")); + fp_vkCmdBuildMicromapsEXT = + reinterpret_cast(procAddr(device, "vkCmdBuildMicromapsEXT")); #endif #if (defined(VK_EXT_opacity_micromap)) fp_vkBuildMicromapsEXT = reinterpret_cast(procAddr(device, "vkBuildMicromapsEXT")); @@ -2526,73 +3410,96 @@ struct DispatchTable { fp_vkCopyMicromapEXT = reinterpret_cast(procAddr(device, "vkCopyMicromapEXT")); #endif #if (defined(VK_EXT_opacity_micromap)) - fp_vkCmdCopyMicromapToMemoryEXT = reinterpret_cast(procAddr(device, "vkCmdCopyMicromapToMemoryEXT")); + fp_vkCmdCopyMicromapToMemoryEXT = + reinterpret_cast(procAddr(device, "vkCmdCopyMicromapToMemoryEXT")); #endif #if (defined(VK_EXT_opacity_micromap)) - fp_vkCopyMicromapToMemoryEXT = reinterpret_cast(procAddr(device, "vkCopyMicromapToMemoryEXT")); + fp_vkCopyMicromapToMemoryEXT = + reinterpret_cast(procAddr(device, "vkCopyMicromapToMemoryEXT")); #endif #if (defined(VK_EXT_opacity_micromap)) - fp_vkCmdCopyMemoryToMicromapEXT = reinterpret_cast(procAddr(device, "vkCmdCopyMemoryToMicromapEXT")); + fp_vkCmdCopyMemoryToMicromapEXT = + reinterpret_cast(procAddr(device, "vkCmdCopyMemoryToMicromapEXT")); #endif #if (defined(VK_EXT_opacity_micromap)) - fp_vkCopyMemoryToMicromapEXT = reinterpret_cast(procAddr(device, "vkCopyMemoryToMicromapEXT")); + fp_vkCopyMemoryToMicromapEXT = + reinterpret_cast(procAddr(device, "vkCopyMemoryToMicromapEXT")); #endif #if (defined(VK_EXT_opacity_micromap)) - fp_vkCmdWriteMicromapsPropertiesEXT = reinterpret_cast(procAddr(device, "vkCmdWriteMicromapsPropertiesEXT")); + fp_vkCmdWriteMicromapsPropertiesEXT = reinterpret_cast( + procAddr(device, "vkCmdWriteMicromapsPropertiesEXT")); #endif #if (defined(VK_EXT_opacity_micromap)) - fp_vkWriteMicromapsPropertiesEXT = reinterpret_cast(procAddr(device, "vkWriteMicromapsPropertiesEXT")); + fp_vkWriteMicromapsPropertiesEXT = + reinterpret_cast(procAddr(device, "vkWriteMicromapsPropertiesEXT")); #endif #if (defined(VK_EXT_opacity_micromap)) - fp_vkGetDeviceMicromapCompatibilityEXT = reinterpret_cast(procAddr(device, "vkGetDeviceMicromapCompatibilityEXT")); + fp_vkGetDeviceMicromapCompatibilityEXT = reinterpret_cast( + procAddr(device, "vkGetDeviceMicromapCompatibilityEXT")); #endif #if (defined(VK_EXT_opacity_micromap)) - fp_vkGetMicromapBuildSizesEXT = reinterpret_cast(procAddr(device, "vkGetMicromapBuildSizesEXT")); + fp_vkGetMicromapBuildSizesEXT = + reinterpret_cast(procAddr(device, "vkGetMicromapBuildSizesEXT")); #endif #if (defined(VK_EXT_shader_module_identifier)) - fp_vkGetShaderModuleIdentifierEXT = reinterpret_cast(procAddr(device, "vkGetShaderModuleIdentifierEXT")); + fp_vkGetShaderModuleIdentifierEXT = + reinterpret_cast(procAddr(device, "vkGetShaderModuleIdentifierEXT")); #endif #if (defined(VK_EXT_shader_module_identifier)) - fp_vkGetShaderModuleCreateInfoIdentifierEXT = reinterpret_cast(procAddr(device, "vkGetShaderModuleCreateInfoIdentifierEXT")); + fp_vkGetShaderModuleCreateInfoIdentifierEXT = reinterpret_cast( + procAddr(device, "vkGetShaderModuleCreateInfoIdentifierEXT")); #endif #if (defined(VK_KHR_maintenance5)) - fp_vkGetImageSubresourceLayout2KHR = reinterpret_cast(procAddr(device, "vkGetImageSubresourceLayout2KHR")); + fp_vkGetImageSubresourceLayout2KHR = + reinterpret_cast(procAddr(device, "vkGetImageSubresourceLayout2KHR")); #endif #if (defined(VK_EXT_pipeline_properties)) - fp_vkGetPipelinePropertiesEXT = reinterpret_cast(procAddr(device, "vkGetPipelinePropertiesEXT")); + fp_vkGetPipelinePropertiesEXT = + reinterpret_cast(procAddr(device, "vkGetPipelinePropertiesEXT")); #endif #if (defined(VK_EXT_metal_objects)) - fp_vkExportMetalObjectsEXT = reinterpret_cast(procAddr(device, "vkExportMetalObjectsEXT")); + fp_vkExportMetalObjectsEXT = + reinterpret_cast(procAddr(device, "vkExportMetalObjectsEXT")); #endif #if (defined(VK_QCOM_tile_properties)) - fp_vkGetFramebufferTilePropertiesQCOM = reinterpret_cast(procAddr(device, "vkGetFramebufferTilePropertiesQCOM")); + fp_vkGetFramebufferTilePropertiesQCOM = reinterpret_cast( + procAddr(device, "vkGetFramebufferTilePropertiesQCOM")); #endif #if (defined(VK_QCOM_tile_properties)) - fp_vkGetDynamicRenderingTilePropertiesQCOM = reinterpret_cast(procAddr(device, "vkGetDynamicRenderingTilePropertiesQCOM")); + fp_vkGetDynamicRenderingTilePropertiesQCOM = reinterpret_cast( + procAddr(device, "vkGetDynamicRenderingTilePropertiesQCOM")); #endif #if (defined(VK_NV_optical_flow)) - fp_vkCreateOpticalFlowSessionNV = reinterpret_cast(procAddr(device, "vkCreateOpticalFlowSessionNV")); + fp_vkCreateOpticalFlowSessionNV = + reinterpret_cast(procAddr(device, "vkCreateOpticalFlowSessionNV")); #endif #if (defined(VK_NV_optical_flow)) - fp_vkDestroyOpticalFlowSessionNV = reinterpret_cast(procAddr(device, "vkDestroyOpticalFlowSessionNV")); + fp_vkDestroyOpticalFlowSessionNV = + reinterpret_cast(procAddr(device, "vkDestroyOpticalFlowSessionNV")); #endif #if (defined(VK_NV_optical_flow)) - fp_vkBindOpticalFlowSessionImageNV = reinterpret_cast(procAddr(device, "vkBindOpticalFlowSessionImageNV")); + fp_vkBindOpticalFlowSessionImageNV = + reinterpret_cast(procAddr(device, "vkBindOpticalFlowSessionImageNV")); #endif #if (defined(VK_NV_optical_flow)) - fp_vkCmdOpticalFlowExecuteNV = reinterpret_cast(procAddr(device, "vkCmdOpticalFlowExecuteNV")); + fp_vkCmdOpticalFlowExecuteNV = + reinterpret_cast(procAddr(device, "vkCmdOpticalFlowExecuteNV")); #endif #if (defined(VK_EXT_device_fault)) - fp_vkGetDeviceFaultInfoEXT = reinterpret_cast(procAddr(device, "vkGetDeviceFaultInfoEXT")); + fp_vkGetDeviceFaultInfoEXT = + reinterpret_cast(procAddr(device, "vkGetDeviceFaultInfoEXT")); #endif #if (defined(VK_EXT_depth_bias_control)) - fp_vkCmdSetDepthBias2EXT = reinterpret_cast(procAddr(device, "vkCmdSetDepthBias2EXT")); + fp_vkCmdSetDepthBias2EXT = + reinterpret_cast(procAddr(device, "vkCmdSetDepthBias2EXT")); #endif #if (defined(VK_EXT_swapchain_maintenance1)) - fp_vkReleaseSwapchainImagesEXT = reinterpret_cast(procAddr(device, "vkReleaseSwapchainImagesEXT")); + fp_vkReleaseSwapchainImagesEXT = + reinterpret_cast(procAddr(device, "vkReleaseSwapchainImagesEXT")); #endif #if (defined(VK_KHR_maintenance5)) - fp_vkGetDeviceImageSubresourceLayoutKHR = reinterpret_cast(procAddr(device, "vkGetDeviceImageSubresourceLayoutKHR")); + fp_vkGetDeviceImageSubresourceLayoutKHR = reinterpret_cast( + procAddr(device, "vkGetDeviceImageSubresourceLayoutKHR")); #endif #if (defined(VK_KHR_map_memory2)) fp_vkMapMemory2KHR = reinterpret_cast(procAddr(device, "vkMapMemory2KHR")); @@ -2607,55 +3514,73 @@ struct DispatchTable { fp_vkDestroyShaderEXT = reinterpret_cast(procAddr(device, "vkDestroyShaderEXT")); #endif #if (defined(VK_EXT_shader_object)) - fp_vkGetShaderBinaryDataEXT = reinterpret_cast(procAddr(device, "vkGetShaderBinaryDataEXT")); + fp_vkGetShaderBinaryDataEXT = + reinterpret_cast(procAddr(device, "vkGetShaderBinaryDataEXT")); #endif #if (defined(VK_EXT_shader_object)) fp_vkCmdBindShadersEXT = reinterpret_cast(procAddr(device, "vkCmdBindShadersEXT")); #endif #if (defined(VK_QNX_external_memory_screen_buffer)) - fp_vkGetScreenBufferPropertiesQNX = reinterpret_cast(procAddr(device, "vkGetScreenBufferPropertiesQNX")); + fp_vkGetScreenBufferPropertiesQNX = + reinterpret_cast(procAddr(device, "vkGetScreenBufferPropertiesQNX")); #endif #if (defined(VK_AMDX_shader_enqueue)) - fp_vkGetExecutionGraphPipelineScratchSizeAMDX = reinterpret_cast(procAddr(device, "vkGetExecutionGraphPipelineScratchSizeAMDX")); + fp_vkGetExecutionGraphPipelineScratchSizeAMDX = + reinterpret_cast( + procAddr(device, "vkGetExecutionGraphPipelineScratchSizeAMDX")); #endif #if (defined(VK_AMDX_shader_enqueue)) - fp_vkGetExecutionGraphPipelineNodeIndexAMDX = reinterpret_cast(procAddr(device, "vkGetExecutionGraphPipelineNodeIndexAMDX")); + fp_vkGetExecutionGraphPipelineNodeIndexAMDX = reinterpret_cast( + procAddr(device, "vkGetExecutionGraphPipelineNodeIndexAMDX")); #endif #if (defined(VK_AMDX_shader_enqueue)) - fp_vkCreateExecutionGraphPipelinesAMDX = reinterpret_cast(procAddr(device, "vkCreateExecutionGraphPipelinesAMDX")); + fp_vkCreateExecutionGraphPipelinesAMDX = reinterpret_cast( + procAddr(device, "vkCreateExecutionGraphPipelinesAMDX")); #endif #if ((defined(VK_AMDX_shader_enqueue))) && VK_HEADER_VERSION >= 298 - fp_vkCmdInitializeGraphScratchMemoryAMDX = reinterpret_cast(procAddr(device, "vkCmdInitializeGraphScratchMemoryAMDX")); + fp_vkCmdInitializeGraphScratchMemoryAMDX = reinterpret_cast( + procAddr(device, "vkCmdInitializeGraphScratchMemoryAMDX")); #endif #if ((defined(VK_AMDX_shader_enqueue))) && VK_HEADER_VERSION >= 298 - fp_vkCmdDispatchGraphAMDX = reinterpret_cast(procAddr(device, "vkCmdDispatchGraphAMDX")); + fp_vkCmdDispatchGraphAMDX = + reinterpret_cast(procAddr(device, "vkCmdDispatchGraphAMDX")); #endif #if ((defined(VK_AMDX_shader_enqueue))) && VK_HEADER_VERSION >= 298 - fp_vkCmdDispatchGraphIndirectAMDX = reinterpret_cast(procAddr(device, "vkCmdDispatchGraphIndirectAMDX")); + fp_vkCmdDispatchGraphIndirectAMDX = + reinterpret_cast(procAddr(device, "vkCmdDispatchGraphIndirectAMDX")); #endif #if ((defined(VK_AMDX_shader_enqueue))) && VK_HEADER_VERSION >= 298 - fp_vkCmdDispatchGraphIndirectCountAMDX = reinterpret_cast(procAddr(device, "vkCmdDispatchGraphIndirectCountAMDX")); + fp_vkCmdDispatchGraphIndirectCountAMDX = reinterpret_cast( + procAddr(device, "vkCmdDispatchGraphIndirectCountAMDX")); #endif #if (defined(VK_KHR_maintenance6)) - fp_vkCmdBindDescriptorSets2KHR = reinterpret_cast(procAddr(device, "vkCmdBindDescriptorSets2KHR")); + fp_vkCmdBindDescriptorSets2KHR = + reinterpret_cast(procAddr(device, "vkCmdBindDescriptorSets2KHR")); #endif #if (defined(VK_KHR_maintenance6)) - fp_vkCmdPushConstants2KHR = reinterpret_cast(procAddr(device, "vkCmdPushConstants2KHR")); + fp_vkCmdPushConstants2KHR = + reinterpret_cast(procAddr(device, "vkCmdPushConstants2KHR")); #endif #if (defined(VK_KHR_maintenance6)) - fp_vkCmdPushDescriptorSet2KHR = reinterpret_cast(procAddr(device, "vkCmdPushDescriptorSet2KHR")); + fp_vkCmdPushDescriptorSet2KHR = + reinterpret_cast(procAddr(device, "vkCmdPushDescriptorSet2KHR")); #endif #if (defined(VK_KHR_maintenance6)) - fp_vkCmdPushDescriptorSetWithTemplate2KHR = reinterpret_cast(procAddr(device, "vkCmdPushDescriptorSetWithTemplate2KHR")); + fp_vkCmdPushDescriptorSetWithTemplate2KHR = reinterpret_cast( + procAddr(device, "vkCmdPushDescriptorSetWithTemplate2KHR")); #endif #if (defined(VK_KHR_maintenance6)) - fp_vkCmdSetDescriptorBufferOffsets2EXT = reinterpret_cast(procAddr(device, "vkCmdSetDescriptorBufferOffsets2EXT")); + fp_vkCmdSetDescriptorBufferOffsets2EXT = reinterpret_cast( + procAddr(device, "vkCmdSetDescriptorBufferOffsets2EXT")); #endif #if (defined(VK_KHR_maintenance6)) - fp_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = reinterpret_cast(procAddr(device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT")); + fp_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = + reinterpret_cast( + procAddr(device, "vkCmdBindDescriptorBufferEmbeddedSamplers2EXT")); #endif #if (defined(VK_NV_low_latency2)) - fp_vkSetLatencySleepModeNV = reinterpret_cast(procAddr(device, "vkSetLatencySleepModeNV")); + fp_vkSetLatencySleepModeNV = + reinterpret_cast(procAddr(device, "vkSetLatencySleepModeNV")); #endif #if (defined(VK_NV_low_latency2)) fp_vkLatencySleepNV = reinterpret_cast(procAddr(device, "vkLatencySleepNV")); @@ -2664,19 +3589,25 @@ struct DispatchTable { fp_vkSetLatencyMarkerNV = reinterpret_cast(procAddr(device, "vkSetLatencyMarkerNV")); #endif #if ((defined(VK_NV_low_latency2))) && VK_HEADER_VERSION >= 271 - fp_vkGetLatencyTimingsNV = reinterpret_cast(procAddr(device, "vkGetLatencyTimingsNV")); + fp_vkGetLatencyTimingsNV = + reinterpret_cast(procAddr(device, "vkGetLatencyTimingsNV")); #endif #if (defined(VK_NV_low_latency2)) - fp_vkQueueNotifyOutOfBandNV = reinterpret_cast(procAddr(device, "vkQueueNotifyOutOfBandNV")); + fp_vkQueueNotifyOutOfBandNV = + reinterpret_cast(procAddr(device, "vkQueueNotifyOutOfBandNV")); #endif #if (defined(VK_KHR_dynamic_rendering_local_read)) - fp_vkCmdSetRenderingAttachmentLocationsKHR = reinterpret_cast(procAddr(device, "vkCmdSetRenderingAttachmentLocationsKHR")); + fp_vkCmdSetRenderingAttachmentLocationsKHR = reinterpret_cast( + procAddr(device, "vkCmdSetRenderingAttachmentLocationsKHR")); #endif #if (defined(VK_KHR_dynamic_rendering_local_read)) - fp_vkCmdSetRenderingInputAttachmentIndicesKHR = reinterpret_cast(procAddr(device, "vkCmdSetRenderingInputAttachmentIndicesKHR")); + fp_vkCmdSetRenderingInputAttachmentIndicesKHR = + reinterpret_cast( + procAddr(device, "vkCmdSetRenderingInputAttachmentIndicesKHR")); #endif #if (defined(VK_EXT_shader_object)) || (defined(VK_EXT_depth_clamp_control)) - fp_vkCmdSetDepthClampRangeEXT = reinterpret_cast(procAddr(device, "vkCmdSetDepthClampRangeEXT")); + fp_vkCmdSetDepthClampRangeEXT = + reinterpret_cast(procAddr(device, "vkCmdSetDepthClampRangeEXT")); #endif #if (defined(VK_EXT_host_query_reset)) fp_vkResetQueryPoolEXT = reinterpret_cast(procAddr(device, "vkResetQueryPoolEXT")); @@ -2685,73 +3616,95 @@ struct DispatchTable { fp_vkTrimCommandPoolKHR = reinterpret_cast(procAddr(device, "vkTrimCommandPoolKHR")); #endif #if (defined(VK_KHR_device_group)) - fp_vkGetDeviceGroupPeerMemoryFeaturesKHR = reinterpret_cast(procAddr(device, "vkGetDeviceGroupPeerMemoryFeaturesKHR")); + fp_vkGetDeviceGroupPeerMemoryFeaturesKHR = reinterpret_cast( + procAddr(device, "vkGetDeviceGroupPeerMemoryFeaturesKHR")); #endif #if (defined(VK_KHR_bind_memory2)) - fp_vkBindBufferMemory2KHR = reinterpret_cast(procAddr(device, "vkBindBufferMemory2KHR")); + fp_vkBindBufferMemory2KHR = + reinterpret_cast(procAddr(device, "vkBindBufferMemory2KHR")); #endif #if (defined(VK_KHR_bind_memory2)) - fp_vkBindImageMemory2KHR = reinterpret_cast(procAddr(device, "vkBindImageMemory2KHR")); + fp_vkBindImageMemory2KHR = + reinterpret_cast(procAddr(device, "vkBindImageMemory2KHR")); #endif #if (defined(VK_KHR_device_group)) - fp_vkCmdSetDeviceMaskKHR = reinterpret_cast(procAddr(device, "vkCmdSetDeviceMaskKHR")); + fp_vkCmdSetDeviceMaskKHR = + reinterpret_cast(procAddr(device, "vkCmdSetDeviceMaskKHR")); #endif #if (defined(VK_KHR_device_group)) fp_vkCmdDispatchBaseKHR = reinterpret_cast(procAddr(device, "vkCmdDispatchBaseKHR")); #endif #if (defined(VK_KHR_descriptor_update_template)) - fp_vkCreateDescriptorUpdateTemplateKHR = reinterpret_cast(procAddr(device, "vkCreateDescriptorUpdateTemplateKHR")); + fp_vkCreateDescriptorUpdateTemplateKHR = reinterpret_cast( + procAddr(device, "vkCreateDescriptorUpdateTemplateKHR")); #endif #if (defined(VK_KHR_descriptor_update_template)) - fp_vkDestroyDescriptorUpdateTemplateKHR = reinterpret_cast(procAddr(device, "vkDestroyDescriptorUpdateTemplateKHR")); + fp_vkDestroyDescriptorUpdateTemplateKHR = reinterpret_cast( + procAddr(device, "vkDestroyDescriptorUpdateTemplateKHR")); #endif #if (defined(VK_KHR_descriptor_update_template)) - fp_vkUpdateDescriptorSetWithTemplateKHR = reinterpret_cast(procAddr(device, "vkUpdateDescriptorSetWithTemplateKHR")); + fp_vkUpdateDescriptorSetWithTemplateKHR = reinterpret_cast( + procAddr(device, "vkUpdateDescriptorSetWithTemplateKHR")); #endif #if (defined(VK_KHR_get_memory_requirements2)) - fp_vkGetBufferMemoryRequirements2KHR = reinterpret_cast(procAddr(device, "vkGetBufferMemoryRequirements2KHR")); + fp_vkGetBufferMemoryRequirements2KHR = reinterpret_cast( + procAddr(device, "vkGetBufferMemoryRequirements2KHR")); #endif #if (defined(VK_KHR_get_memory_requirements2)) - fp_vkGetImageMemoryRequirements2KHR = reinterpret_cast(procAddr(device, "vkGetImageMemoryRequirements2KHR")); + fp_vkGetImageMemoryRequirements2KHR = reinterpret_cast( + procAddr(device, "vkGetImageMemoryRequirements2KHR")); #endif #if (defined(VK_KHR_get_memory_requirements2)) - fp_vkGetImageSparseMemoryRequirements2KHR = reinterpret_cast(procAddr(device, "vkGetImageSparseMemoryRequirements2KHR")); + fp_vkGetImageSparseMemoryRequirements2KHR = reinterpret_cast( + procAddr(device, "vkGetImageSparseMemoryRequirements2KHR")); #endif #if (defined(VK_KHR_maintenance4)) - fp_vkGetDeviceBufferMemoryRequirementsKHR = reinterpret_cast(procAddr(device, "vkGetDeviceBufferMemoryRequirementsKHR")); + fp_vkGetDeviceBufferMemoryRequirementsKHR = reinterpret_cast( + procAddr(device, "vkGetDeviceBufferMemoryRequirementsKHR")); #endif #if (defined(VK_KHR_maintenance4)) - fp_vkGetDeviceImageMemoryRequirementsKHR = reinterpret_cast(procAddr(device, "vkGetDeviceImageMemoryRequirementsKHR")); + fp_vkGetDeviceImageMemoryRequirementsKHR = reinterpret_cast( + procAddr(device, "vkGetDeviceImageMemoryRequirementsKHR")); #endif #if (defined(VK_KHR_maintenance4)) - fp_vkGetDeviceImageSparseMemoryRequirementsKHR = reinterpret_cast(procAddr(device, "vkGetDeviceImageSparseMemoryRequirementsKHR")); + fp_vkGetDeviceImageSparseMemoryRequirementsKHR = + reinterpret_cast( + procAddr(device, "vkGetDeviceImageSparseMemoryRequirementsKHR")); #endif #if (defined(VK_KHR_sampler_ycbcr_conversion)) - fp_vkCreateSamplerYcbcrConversionKHR = reinterpret_cast(procAddr(device, "vkCreateSamplerYcbcrConversionKHR")); + fp_vkCreateSamplerYcbcrConversionKHR = reinterpret_cast( + procAddr(device, "vkCreateSamplerYcbcrConversionKHR")); #endif #if (defined(VK_KHR_sampler_ycbcr_conversion)) - fp_vkDestroySamplerYcbcrConversionKHR = reinterpret_cast(procAddr(device, "vkDestroySamplerYcbcrConversionKHR")); + fp_vkDestroySamplerYcbcrConversionKHR = reinterpret_cast( + procAddr(device, "vkDestroySamplerYcbcrConversionKHR")); #endif #if (defined(VK_KHR_maintenance3)) - fp_vkGetDescriptorSetLayoutSupportKHR = reinterpret_cast(procAddr(device, "vkGetDescriptorSetLayoutSupportKHR")); + fp_vkGetDescriptorSetLayoutSupportKHR = reinterpret_cast( + procAddr(device, "vkGetDescriptorSetLayoutSupportKHR")); #endif #if (defined(VK_EXT_calibrated_timestamps)) - fp_vkGetCalibratedTimestampsEXT = reinterpret_cast(procAddr(device, "vkGetCalibratedTimestampsEXT")); + fp_vkGetCalibratedTimestampsEXT = + reinterpret_cast(procAddr(device, "vkGetCalibratedTimestampsEXT")); #endif #if (defined(VK_KHR_create_renderpass2)) - fp_vkCreateRenderPass2KHR = reinterpret_cast(procAddr(device, "vkCreateRenderPass2KHR")); + fp_vkCreateRenderPass2KHR = + reinterpret_cast(procAddr(device, "vkCreateRenderPass2KHR")); #endif #if (defined(VK_KHR_create_renderpass2)) - fp_vkCmdBeginRenderPass2KHR = reinterpret_cast(procAddr(device, "vkCmdBeginRenderPass2KHR")); + fp_vkCmdBeginRenderPass2KHR = + reinterpret_cast(procAddr(device, "vkCmdBeginRenderPass2KHR")); #endif #if (defined(VK_KHR_create_renderpass2)) fp_vkCmdNextSubpass2KHR = reinterpret_cast(procAddr(device, "vkCmdNextSubpass2KHR")); #endif #if (defined(VK_KHR_create_renderpass2)) - fp_vkCmdEndRenderPass2KHR = reinterpret_cast(procAddr(device, "vkCmdEndRenderPass2KHR")); + fp_vkCmdEndRenderPass2KHR = + reinterpret_cast(procAddr(device, "vkCmdEndRenderPass2KHR")); #endif #if (defined(VK_KHR_timeline_semaphore)) - fp_vkGetSemaphoreCounterValueKHR = reinterpret_cast(procAddr(device, "vkGetSemaphoreCounterValueKHR")); + fp_vkGetSemaphoreCounterValueKHR = + reinterpret_cast(procAddr(device, "vkGetSemaphoreCounterValueKHR")); #endif #if (defined(VK_KHR_timeline_semaphore)) fp_vkWaitSemaphoresKHR = reinterpret_cast(procAddr(device, "vkWaitSemaphoresKHR")); @@ -2760,25 +3713,32 @@ struct DispatchTable { fp_vkSignalSemaphoreKHR = reinterpret_cast(procAddr(device, "vkSignalSemaphoreKHR")); #endif #if (defined(VK_AMD_draw_indirect_count)) - fp_vkCmdDrawIndirectCountAMD = reinterpret_cast(procAddr(device, "vkCmdDrawIndirectCountAMD")); + fp_vkCmdDrawIndirectCountAMD = + reinterpret_cast(procAddr(device, "vkCmdDrawIndirectCountAMD")); #endif #if (defined(VK_AMD_draw_indirect_count)) - fp_vkCmdDrawIndexedIndirectCountAMD = reinterpret_cast(procAddr(device, "vkCmdDrawIndexedIndirectCountAMD")); + fp_vkCmdDrawIndexedIndirectCountAMD = reinterpret_cast( + procAddr(device, "vkCmdDrawIndexedIndirectCountAMD")); #endif #if (defined(VK_NV_ray_tracing)) - fp_vkGetRayTracingShaderGroupHandlesNV = reinterpret_cast(procAddr(device, "vkGetRayTracingShaderGroupHandlesNV")); + fp_vkGetRayTracingShaderGroupHandlesNV = reinterpret_cast( + procAddr(device, "vkGetRayTracingShaderGroupHandlesNV")); #endif #if (defined(VK_KHR_buffer_device_address)) - fp_vkGetBufferOpaqueCaptureAddressKHR = reinterpret_cast(procAddr(device, "vkGetBufferOpaqueCaptureAddressKHR")); + fp_vkGetBufferOpaqueCaptureAddressKHR = reinterpret_cast( + procAddr(device, "vkGetBufferOpaqueCaptureAddressKHR")); #endif #if (defined(VK_EXT_buffer_device_address)) - fp_vkGetBufferDeviceAddressEXT = reinterpret_cast(procAddr(device, "vkGetBufferDeviceAddressEXT")); + fp_vkGetBufferDeviceAddressEXT = + reinterpret_cast(procAddr(device, "vkGetBufferDeviceAddressEXT")); #endif #if (defined(VK_KHR_buffer_device_address)) - fp_vkGetDeviceMemoryOpaqueCaptureAddressKHR = reinterpret_cast(procAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")); + fp_vkGetDeviceMemoryOpaqueCaptureAddressKHR = reinterpret_cast( + procAddr(device, "vkGetDeviceMemoryOpaqueCaptureAddressKHR")); #endif #if (defined(VK_EXT_line_rasterization)) - fp_vkCmdSetLineStippleEXT = reinterpret_cast(procAddr(device, "vkCmdSetLineStippleEXT")); + fp_vkCmdSetLineStippleEXT = + reinterpret_cast(procAddr(device, "vkCmdSetLineStippleEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) fp_vkCmdSetCullModeEXT = reinterpret_cast(procAddr(device, "vkCmdSetCullModeEXT")); @@ -2787,49 +3747,63 @@ struct DispatchTable { fp_vkCmdSetFrontFaceEXT = reinterpret_cast(procAddr(device, "vkCmdSetFrontFaceEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetPrimitiveTopologyEXT = reinterpret_cast(procAddr(device, "vkCmdSetPrimitiveTopologyEXT")); + fp_vkCmdSetPrimitiveTopologyEXT = + reinterpret_cast(procAddr(device, "vkCmdSetPrimitiveTopologyEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetViewportWithCountEXT = reinterpret_cast(procAddr(device, "vkCmdSetViewportWithCountEXT")); + fp_vkCmdSetViewportWithCountEXT = + reinterpret_cast(procAddr(device, "vkCmdSetViewportWithCountEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetScissorWithCountEXT = reinterpret_cast(procAddr(device, "vkCmdSetScissorWithCountEXT")); + fp_vkCmdSetScissorWithCountEXT = + reinterpret_cast(procAddr(device, "vkCmdSetScissorWithCountEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - fp_vkCmdBindVertexBuffers2EXT = reinterpret_cast(procAddr(device, "vkCmdBindVertexBuffers2EXT")); + fp_vkCmdBindVertexBuffers2EXT = + reinterpret_cast(procAddr(device, "vkCmdBindVertexBuffers2EXT")); #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetDepthTestEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetDepthTestEnableEXT")); + fp_vkCmdSetDepthTestEnableEXT = + reinterpret_cast(procAddr(device, "vkCmdSetDepthTestEnableEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetDepthWriteEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetDepthWriteEnableEXT")); + fp_vkCmdSetDepthWriteEnableEXT = + reinterpret_cast(procAddr(device, "vkCmdSetDepthWriteEnableEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetDepthCompareOpEXT = reinterpret_cast(procAddr(device, "vkCmdSetDepthCompareOpEXT")); + fp_vkCmdSetDepthCompareOpEXT = + reinterpret_cast(procAddr(device, "vkCmdSetDepthCompareOpEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetDepthBoundsTestEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetDepthBoundsTestEnableEXT")); + fp_vkCmdSetDepthBoundsTestEnableEXT = reinterpret_cast( + procAddr(device, "vkCmdSetDepthBoundsTestEnableEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetStencilTestEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetStencilTestEnableEXT")); + fp_vkCmdSetStencilTestEnableEXT = + reinterpret_cast(procAddr(device, "vkCmdSetStencilTestEnableEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) fp_vkCmdSetStencilOpEXT = reinterpret_cast(procAddr(device, "vkCmdSetStencilOpEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetRasterizerDiscardEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetRasterizerDiscardEnableEXT")); + fp_vkCmdSetRasterizerDiscardEnableEXT = reinterpret_cast( + procAddr(device, "vkCmdSetRasterizerDiscardEnableEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetDepthBiasEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetDepthBiasEnableEXT")); + fp_vkCmdSetDepthBiasEnableEXT = + reinterpret_cast(procAddr(device, "vkCmdSetDepthBiasEnableEXT")); #endif #if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) - fp_vkCmdSetPrimitiveRestartEnableEXT = reinterpret_cast(procAddr(device, "vkCmdSetPrimitiveRestartEnableEXT")); + fp_vkCmdSetPrimitiveRestartEnableEXT = reinterpret_cast( + procAddr(device, "vkCmdSetPrimitiveRestartEnableEXT")); #endif #if (defined(VK_EXT_private_data)) - fp_vkCreatePrivateDataSlotEXT = reinterpret_cast(procAddr(device, "vkCreatePrivateDataSlotEXT")); + fp_vkCreatePrivateDataSlotEXT = + reinterpret_cast(procAddr(device, "vkCreatePrivateDataSlotEXT")); #endif #if (defined(VK_EXT_private_data)) - fp_vkDestroyPrivateDataSlotEXT = reinterpret_cast(procAddr(device, "vkDestroyPrivateDataSlotEXT")); + fp_vkDestroyPrivateDataSlotEXT = + reinterpret_cast(procAddr(device, "vkDestroyPrivateDataSlotEXT")); #endif #if (defined(VK_EXT_private_data)) fp_vkSetPrivateDataEXT = reinterpret_cast(procAddr(device, "vkSetPrivateDataEXT")); @@ -2847,13 +3821,16 @@ struct DispatchTable { fp_vkCmdBlitImage2KHR = reinterpret_cast(procAddr(device, "vkCmdBlitImage2KHR")); #endif #if (defined(VK_KHR_copy_commands2)) - fp_vkCmdCopyBufferToImage2KHR = reinterpret_cast(procAddr(device, "vkCmdCopyBufferToImage2KHR")); + fp_vkCmdCopyBufferToImage2KHR = + reinterpret_cast(procAddr(device, "vkCmdCopyBufferToImage2KHR")); #endif #if (defined(VK_KHR_copy_commands2)) - fp_vkCmdCopyImageToBuffer2KHR = reinterpret_cast(procAddr(device, "vkCmdCopyImageToBuffer2KHR")); + fp_vkCmdCopyImageToBuffer2KHR = + reinterpret_cast(procAddr(device, "vkCmdCopyImageToBuffer2KHR")); #endif #if (defined(VK_KHR_copy_commands2)) - fp_vkCmdResolveImage2KHR = reinterpret_cast(procAddr(device, "vkCmdResolveImage2KHR")); + fp_vkCmdResolveImage2KHR = + reinterpret_cast(procAddr(device, "vkCmdResolveImage2KHR")); #endif #if (defined(VK_KHR_synchronization2)) fp_vkCmdSetEvent2KHR = reinterpret_cast(procAddr(device, "vkCmdSetEvent2KHR")); @@ -2865,5225 +3842,6833 @@ struct DispatchTable { fp_vkCmdWaitEvents2KHR = reinterpret_cast(procAddr(device, "vkCmdWaitEvents2KHR")); #endif #if (defined(VK_KHR_synchronization2)) - fp_vkCmdPipelineBarrier2KHR = reinterpret_cast(procAddr(device, "vkCmdPipelineBarrier2KHR")); + fp_vkCmdPipelineBarrier2KHR = + reinterpret_cast(procAddr(device, "vkCmdPipelineBarrier2KHR")); #endif #if (defined(VK_KHR_synchronization2)) fp_vkQueueSubmit2KHR = reinterpret_cast(procAddr(device, "vkQueueSubmit2KHR")); #endif #if (defined(VK_KHR_synchronization2)) - fp_vkCmdWriteTimestamp2KHR = reinterpret_cast(procAddr(device, "vkCmdWriteTimestamp2KHR")); + fp_vkCmdWriteTimestamp2KHR = + reinterpret_cast(procAddr(device, "vkCmdWriteTimestamp2KHR")); #endif #if (defined(VK_KHR_dynamic_rendering)) - fp_vkCmdBeginRenderingKHR = reinterpret_cast(procAddr(device, "vkCmdBeginRenderingKHR")); + fp_vkCmdBeginRenderingKHR = + reinterpret_cast(procAddr(device, "vkCmdBeginRenderingKHR")); #endif #if (defined(VK_KHR_dynamic_rendering)) fp_vkCmdEndRenderingKHR = reinterpret_cast(procAddr(device, "vkCmdEndRenderingKHR")); #endif #if (defined(VK_EXT_host_image_copy)) || (defined(VK_EXT_image_compression_control)) - fp_vkGetImageSubresourceLayout2EXT = reinterpret_cast(procAddr(device, "vkGetImageSubresourceLayout2EXT")); + fp_vkGetImageSubresourceLayout2EXT = + reinterpret_cast(procAddr(device, "vkGetImageSubresourceLayout2EXT")); #endif } - void getDeviceQueue(uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) const noexcept { + void getDeviceQueue(uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) const noexcept + { fp_vkGetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); } - VkResult queueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) const noexcept { + VkResult + queueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) const noexcept + { return fp_vkQueueSubmit(queue, submitCount, pSubmits, fence); } - VkResult queueWaitIdle(VkQueue queue) const noexcept { - return fp_vkQueueWaitIdle(queue); - } - VkResult deviceWaitIdle() const noexcept { - return fp_vkDeviceWaitIdle(device); - } - VkResult allocateMemory(const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) const noexcept { + VkResult queueWaitIdle(VkQueue queue) const noexcept { return fp_vkQueueWaitIdle(queue); } + VkResult deviceWaitIdle() const noexcept { return fp_vkDeviceWaitIdle(device); } + VkResult allocateMemory(const VkMemoryAllocateInfo* pAllocateInfo, + const VkAllocationCallbacks* pAllocator, + VkDeviceMemory* pMemory) const noexcept + { return fp_vkAllocateMemory(device, pAllocateInfo, pAllocator, pMemory); } - void freeMemory(VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) const noexcept { + void freeMemory(VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkFreeMemory(device, memory, pAllocator); } - VkResult mapMemory(VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) const noexcept { + VkResult mapMemory(VkDeviceMemory memory, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData) const noexcept + { return fp_vkMapMemory(device, memory, offset, size, flags, ppData); } - void unmapMemory(VkDeviceMemory memory) const noexcept { - fp_vkUnmapMemory(device, memory); - } - VkResult flushMappedMemoryRanges(uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) const noexcept { + void unmapMemory(VkDeviceMemory memory) const noexcept { fp_vkUnmapMemory(device, memory); } + VkResult flushMappedMemoryRanges(uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) const noexcept + { return fp_vkFlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); } - VkResult invalidateMappedMemoryRanges(uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) const noexcept { + VkResult invalidateMappedMemoryRanges(uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges) const noexcept + { return fp_vkInvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); } - void getDeviceMemoryCommitment(VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) const noexcept { + void getDeviceMemoryCommitment(VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) const noexcept + { fp_vkGetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); } - void getBufferMemoryRequirements(VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) const noexcept { + void getBufferMemoryRequirements(VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) const noexcept + { fp_vkGetBufferMemoryRequirements(device, buffer, pMemoryRequirements); } - VkResult bindBufferMemory(VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) const noexcept { + VkResult bindBufferMemory(VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) const noexcept + { return fp_vkBindBufferMemory(device, buffer, memory, memoryOffset); } - void getImageMemoryRequirements(VkImage image, VkMemoryRequirements* pMemoryRequirements) const noexcept { + void getImageMemoryRequirements(VkImage image, VkMemoryRequirements* pMemoryRequirements) const noexcept + { fp_vkGetImageMemoryRequirements(device, image, pMemoryRequirements); } - VkResult bindImageMemory(VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) const noexcept { + VkResult bindImageMemory(VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) const noexcept + { return fp_vkBindImageMemory(device, image, memory, memoryOffset); } - void getImageSparseMemoryRequirements(VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) const noexcept { + void getImageSparseMemoryRequirements(VkImage image, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements) const noexcept + { fp_vkGetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } - VkResult queueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) const noexcept { + VkResult queueBindSparse(VkQueue queue, + uint32_t bindInfoCount, + const VkBindSparseInfo* pBindInfo, + VkFence fence) const noexcept + { return fp_vkQueueBindSparse(queue, bindInfoCount, pBindInfo, fence); } - VkResult createFence(const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const noexcept { + VkResult createFence(const VkFenceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence) const noexcept + { return fp_vkCreateFence(device, pCreateInfo, pAllocator, pFence); } - void destroyFence(VkFence fence, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyFence(VkFence fence, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyFence(device, fence, pAllocator); } - VkResult resetFences(uint32_t fenceCount, const VkFence* pFences) const noexcept { + VkResult resetFences(uint32_t fenceCount, const VkFence* pFences) const noexcept + { return fp_vkResetFences(device, fenceCount, pFences); } - VkResult getFenceStatus(VkFence fence) const noexcept { - return fp_vkGetFenceStatus(device, fence); - } - VkResult waitForFences(uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) const noexcept { + VkResult getFenceStatus(VkFence fence) const noexcept { return fp_vkGetFenceStatus(device, fence); } + VkResult + waitForFences(uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) const noexcept + { return fp_vkWaitForFences(device, fenceCount, pFences, waitAll, timeout); } - VkResult createSemaphore(const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) const noexcept { + VkResult createSemaphore(const VkSemaphoreCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSemaphore* pSemaphore) const noexcept + { return fp_vkCreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); } - void destroySemaphore(VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroySemaphore(VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroySemaphore(device, semaphore, pAllocator); } - VkResult createEvent(const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) const noexcept { + VkResult createEvent(const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkEvent* pEvent) const noexcept + { return fp_vkCreateEvent(device, pCreateInfo, pAllocator, pEvent); } - void destroyEvent(VkEvent event, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyEvent(VkEvent event, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyEvent(device, event, pAllocator); } - VkResult getEventStatus(VkEvent event) const noexcept { - return fp_vkGetEventStatus(device, event); - } - VkResult setEvent(VkEvent event) const noexcept { - return fp_vkSetEvent(device, event); - } - VkResult resetEvent(VkEvent event) const noexcept { - return fp_vkResetEvent(device, event); - } - VkResult createQueryPool(const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) const noexcept { + VkResult getEventStatus(VkEvent event) const noexcept { return fp_vkGetEventStatus(device, event); } + VkResult setEvent(VkEvent event) const noexcept { return fp_vkSetEvent(device, event); } + VkResult resetEvent(VkEvent event) const noexcept { return fp_vkResetEvent(device, event); } + VkResult createQueryPool(const VkQueryPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkQueryPool* pQueryPool) const noexcept + { return fp_vkCreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); } - void destroyQueryPool(VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyQueryPool(VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyQueryPool(device, queryPool, pAllocator); } - VkResult getQueryPoolResults(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) const noexcept { + VkResult getQueryPoolResults(VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + void* pData, + VkDeviceSize stride, + VkQueryResultFlags flags) const noexcept + { return fp_vkGetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); } #if (defined(VK_VERSION_1_2)) - void resetQueryPool(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const noexcept { + void resetQueryPool(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const noexcept + { fp_vkResetQueryPool(device, queryPool, firstQuery, queryCount); } #endif - VkResult createBuffer(const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) const noexcept { + VkResult createBuffer(const VkBufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBuffer* pBuffer) const noexcept + { return fp_vkCreateBuffer(device, pCreateInfo, pAllocator, pBuffer); } - void destroyBuffer(VkBuffer buffer, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyBuffer(VkBuffer buffer, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyBuffer(device, buffer, pAllocator); } - VkResult createBufferView(const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) const noexcept { + VkResult createBufferView(const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferView* pView) const noexcept + { return fp_vkCreateBufferView(device, pCreateInfo, pAllocator, pView); } - void destroyBufferView(VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyBufferView(VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyBufferView(device, bufferView, pAllocator); } - VkResult createImage(const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) const noexcept { + VkResult createImage(const VkImageCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImage* pImage) const noexcept + { return fp_vkCreateImage(device, pCreateInfo, pAllocator, pImage); } - void destroyImage(VkImage image, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyImage(VkImage image, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyImage(device, image, pAllocator); } - void getImageSubresourceLayout(VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) const noexcept { + void getImageSubresourceLayout(VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout) const noexcept + { fp_vkGetImageSubresourceLayout(device, image, pSubresource, pLayout); } - VkResult createImageView(const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) const noexcept { + VkResult createImageView(const VkImageViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImageView* pView) const noexcept + { return fp_vkCreateImageView(device, pCreateInfo, pAllocator, pView); } - void destroyImageView(VkImageView imageView, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyImageView(VkImageView imageView, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyImageView(device, imageView, pAllocator); } - VkResult createShaderModule(const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) const noexcept { + VkResult createShaderModule(const VkShaderModuleCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkShaderModule* pShaderModule) const noexcept + { return fp_vkCreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); } - void destroyShaderModule(VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyShaderModule(VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyShaderModule(device, shaderModule, pAllocator); } - VkResult createPipelineCache(const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) const noexcept { + VkResult createPipelineCache(const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache) const noexcept + { return fp_vkCreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); } - void destroyPipelineCache(VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyPipelineCache(VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyPipelineCache(device, pipelineCache, pAllocator); } - VkResult getPipelineCacheData(VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) const noexcept { + VkResult getPipelineCacheData(VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) const noexcept + { return fp_vkGetPipelineCacheData(device, pipelineCache, pDataSize, pData); } - VkResult mergePipelineCaches(VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) const noexcept { + VkResult mergePipelineCaches(VkPipelineCache dstCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches) const noexcept + { return fp_vkMergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); } #if (defined(VK_KHR_pipeline_binary)) - VkResult createPipelineBinariesKHR(const VkPipelineBinaryCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineBinaryHandlesInfoKHR* pBinaries) const noexcept { + VkResult createPipelineBinariesKHR(const VkPipelineBinaryCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineBinaryHandlesInfoKHR* pBinaries) const noexcept + { return fp_vkCreatePipelineBinariesKHR(device, pCreateInfo, pAllocator, pBinaries); } #endif #if (defined(VK_KHR_pipeline_binary)) - void destroyPipelineBinaryKHR(VkPipelineBinaryKHR pipelineBinary, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyPipelineBinaryKHR(VkPipelineBinaryKHR pipelineBinary, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyPipelineBinaryKHR(device, pipelineBinary, pAllocator); } #endif #if (defined(VK_KHR_pipeline_binary)) - VkResult getPipelineKeyKHR(const VkPipelineCreateInfoKHR* pPipelineCreateInfo, VkPipelineBinaryKeyKHR* pPipelineKey) const noexcept { + VkResult getPipelineKeyKHR(const VkPipelineCreateInfoKHR* pPipelineCreateInfo, + VkPipelineBinaryKeyKHR* pPipelineKey) const noexcept + { return fp_vkGetPipelineKeyKHR(device, pPipelineCreateInfo, pPipelineKey); } #endif #if (defined(VK_KHR_pipeline_binary)) - VkResult getPipelineBinaryDataKHR(const VkPipelineBinaryDataInfoKHR* pInfo, VkPipelineBinaryKeyKHR* pPipelineBinaryKey, size_t* pPipelineBinaryDataSize, void* pPipelineBinaryData) const noexcept { - return fp_vkGetPipelineBinaryDataKHR(device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData); + VkResult getPipelineBinaryDataKHR(const VkPipelineBinaryDataInfoKHR* pInfo, + VkPipelineBinaryKeyKHR* pPipelineBinaryKey, + size_t* pPipelineBinaryDataSize, + void* pPipelineBinaryData) const noexcept + { + return fp_vkGetPipelineBinaryDataKHR( + device, pInfo, pPipelineBinaryKey, pPipelineBinaryDataSize, pPipelineBinaryData); } #endif #if (defined(VK_KHR_pipeline_binary)) - VkResult releaseCapturedPipelineDataKHR(const VkReleaseCapturedPipelineDataInfoKHR* pInfo, const VkAllocationCallbacks* pAllocator) const noexcept { + VkResult releaseCapturedPipelineDataKHR(const VkReleaseCapturedPipelineDataInfoKHR* pInfo, + const VkAllocationCallbacks* pAllocator) const noexcept + { return fp_vkReleaseCapturedPipelineDataKHR(device, pInfo, pAllocator); } #endif - VkResult createGraphicsPipelines(VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const noexcept { - return fp_vkCreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); - } - VkResult createComputePipelines(VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const noexcept { - return fp_vkCreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + VkResult createGraphicsPipelines(VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) const noexcept + { + return fp_vkCreateGraphicsPipelines( + device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + } + VkResult createComputePipelines(VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) const noexcept + { + return fp_vkCreateComputePipelines( + device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); } #if (defined(VK_HUAWEI_subpass_shading)) - VkResult getDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize) const noexcept { + VkResult getDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkRenderPass renderpass, + VkExtent2D* pMaxWorkgroupSize) const noexcept + { return fp_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize); } #endif - void destroyPipeline(VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyPipeline(VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyPipeline(device, pipeline, pAllocator); } - VkResult createPipelineLayout(const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) const noexcept { + VkResult createPipelineLayout(const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineLayout* pPipelineLayout) const noexcept + { return fp_vkCreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); } - void destroyPipelineLayout(VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyPipelineLayout(VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyPipelineLayout(device, pipelineLayout, pAllocator); } - VkResult createSampler(const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) const noexcept { + VkResult createSampler(const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSampler* pSampler) const noexcept + { return fp_vkCreateSampler(device, pCreateInfo, pAllocator, pSampler); } - void destroySampler(VkSampler sampler, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroySampler(VkSampler sampler, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroySampler(device, sampler, pAllocator); } - VkResult createDescriptorSetLayout(const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) const noexcept { + VkResult createDescriptorSetLayout(const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorSetLayout* pSetLayout) const noexcept + { return fp_vkCreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); } - void destroyDescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyDescriptorSetLayout(VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); } - VkResult createDescriptorPool(const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) const noexcept { + VkResult createDescriptorPool(const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorPool* pDescriptorPool) const noexcept + { return fp_vkCreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); } - void destroyDescriptorPool(VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyDescriptorPool(VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyDescriptorPool(device, descriptorPool, pAllocator); } - VkResult resetDescriptorPool(VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) const noexcept { + VkResult resetDescriptorPool(VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) const noexcept + { return fp_vkResetDescriptorPool(device, descriptorPool, flags); } - VkResult allocateDescriptorSets(const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) const noexcept { + VkResult allocateDescriptorSets(const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets) const noexcept + { return fp_vkAllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); } - VkResult freeDescriptorSets(VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) const noexcept { + VkResult freeDescriptorSets(VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets) const noexcept + { return fp_vkFreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); } - void updateDescriptorSets(uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) const noexcept { - fp_vkUpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); - } - VkResult createFramebuffer(const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) const noexcept { + void updateDescriptorSets(uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies) const noexcept + { + fp_vkUpdateDescriptorSets( + device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); + } + VkResult createFramebuffer(const VkFramebufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFramebuffer* pFramebuffer) const noexcept + { return fp_vkCreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); } - void destroyFramebuffer(VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyFramebuffer(VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyFramebuffer(device, framebuffer, pAllocator); } - VkResult createRenderPass(const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) const noexcept { + VkResult createRenderPass(const VkRenderPassCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass) const noexcept + { return fp_vkCreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); } - void destroyRenderPass(VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyRenderPass(VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyRenderPass(device, renderPass, pAllocator); } - void getRenderAreaGranularity(VkRenderPass renderPass, VkExtent2D* pGranularity) const noexcept { + void getRenderAreaGranularity(VkRenderPass renderPass, VkExtent2D* pGranularity) const noexcept + { fp_vkGetRenderAreaGranularity(device, renderPass, pGranularity); } #if (defined(VK_KHR_maintenance5)) - void getRenderingAreaGranularityKHR(const VkRenderingAreaInfoKHR* pRenderingAreaInfo, VkExtent2D* pGranularity) const noexcept { + void getRenderingAreaGranularityKHR(const VkRenderingAreaInfoKHR* pRenderingAreaInfo, + VkExtent2D* pGranularity) const noexcept + { fp_vkGetRenderingAreaGranularityKHR(device, pRenderingAreaInfo, pGranularity); } #endif - VkResult createCommandPool(const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) const noexcept { + VkResult createCommandPool(const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool) const noexcept + { return fp_vkCreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); } - void destroyCommandPool(VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyCommandPool(VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyCommandPool(device, commandPool, pAllocator); } - VkResult resetCommandPool(VkCommandPool commandPool, VkCommandPoolResetFlags flags) const noexcept { + VkResult resetCommandPool(VkCommandPool commandPool, VkCommandPoolResetFlags flags) const noexcept + { return fp_vkResetCommandPool(device, commandPool, flags); } - VkResult allocateCommandBuffers(const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) const noexcept { + VkResult allocateCommandBuffers(const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers) const noexcept + { return fp_vkAllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); } - void freeCommandBuffers(VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) const noexcept { + void freeCommandBuffers(VkCommandPool commandPool, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers) const noexcept + { fp_vkFreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); } - VkResult beginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) const noexcept { + VkResult beginCommandBuffer(VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo) const noexcept + { return fp_vkBeginCommandBuffer(commandBuffer, pBeginInfo); } - VkResult endCommandBuffer(VkCommandBuffer commandBuffer) const noexcept { + VkResult endCommandBuffer(VkCommandBuffer commandBuffer) const noexcept + { return fp_vkEndCommandBuffer(commandBuffer); } - VkResult resetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) const noexcept { + VkResult resetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) const noexcept + { return fp_vkResetCommandBuffer(commandBuffer, flags); } - void cmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const noexcept { + void cmdBindPipeline(VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline) const noexcept + { fp_vkCmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); } #if (defined(VK_EXT_attachment_feedback_loop_dynamic_state)) - void cmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, VkImageAspectFlags aspectMask) const noexcept { + void cmdSetAttachmentFeedbackLoopEnableEXT(VkCommandBuffer commandBuffer, + VkImageAspectFlags aspectMask) const noexcept + { fp_vkCmdSetAttachmentFeedbackLoopEnableEXT(commandBuffer, aspectMask); } #endif - void cmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) const noexcept { + void cmdSetViewport(VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewport* pViewports) const noexcept + { fp_vkCmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); } - void cmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) const noexcept { + void cmdSetScissor(VkCommandBuffer commandBuffer, + uint32_t firstScissor, + uint32_t scissorCount, + const VkRect2D* pScissors) const noexcept + { fp_vkCmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); } - void cmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) const noexcept { + void cmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) const noexcept + { fp_vkCmdSetLineWidth(commandBuffer, lineWidth); } - void cmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) const noexcept { + void cmdSetDepthBias(VkCommandBuffer commandBuffer, + float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor) const noexcept + { fp_vkCmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); } - void cmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) const noexcept { + void cmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) const noexcept + { fp_vkCmdSetBlendConstants(commandBuffer, blendConstants); } - void cmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) const noexcept { + void cmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) const noexcept + { fp_vkCmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); } - void cmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) const noexcept { + void cmdSetStencilCompareMask(VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t compareMask) const noexcept + { fp_vkCmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); } - void cmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) const noexcept { + void cmdSetStencilWriteMask(VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t writeMask) const noexcept + { fp_vkCmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); } - void cmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) const noexcept { + void cmdSetStencilReference(VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t reference) const noexcept + { fp_vkCmdSetStencilReference(commandBuffer, faceMask, reference); } - void cmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) const noexcept { - fp_vkCmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); - } - void cmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) const noexcept { + void cmdBindDescriptorSets(VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets) const noexcept + { + fp_vkCmdBindDescriptorSets(commandBuffer, + pipelineBindPoint, + layout, + firstSet, + descriptorSetCount, + pDescriptorSets, + dynamicOffsetCount, + pDynamicOffsets); + } + void cmdBindIndexBuffer(VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType) const noexcept + { fp_vkCmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); } - void cmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) const noexcept { + void cmdBindVertexBuffers(VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets) const noexcept + { fp_vkCmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); } - void cmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) const noexcept { + void cmdDraw(VkCommandBuffer commandBuffer, + uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance) const noexcept + { fp_vkCmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); } - void cmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) const noexcept { + void cmdDrawIndexed(VkCommandBuffer commandBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance) const noexcept + { fp_vkCmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); } #if (defined(VK_EXT_multi_draw)) - void cmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) const noexcept { + void cmdDrawMultiEXT(VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawInfoEXT* pVertexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride) const noexcept + { fp_vkCmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride); } #endif #if (defined(VK_EXT_multi_draw)) - void cmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) const noexcept { - fp_vkCmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset); - } -#endif - void cmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const noexcept { + void cmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawIndexedInfoEXT* pIndexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride, + const int32_t* pVertexOffset) const noexcept + { + fp_vkCmdDrawMultiIndexedEXT( + commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset); + } +#endif + void cmdDrawIndirect(VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) const noexcept + { fp_vkCmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); } - void cmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const noexcept { + void cmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) const noexcept + { fp_vkCmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); } - void cmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const noexcept { + void cmdDispatch(VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ) const noexcept + { fp_vkCmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); } - void cmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const noexcept { + void cmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const noexcept + { fp_vkCmdDispatchIndirect(commandBuffer, buffer, offset); } #if (defined(VK_HUAWEI_subpass_shading)) - void cmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) const noexcept { + void cmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) const noexcept + { fp_vkCmdSubpassShadingHUAWEI(commandBuffer); } #endif #if (defined(VK_HUAWEI_cluster_culling_shader)) - void cmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const noexcept { + void cmdDrawClusterHUAWEI(VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ) const noexcept + { fp_vkCmdDrawClusterHUAWEI(commandBuffer, groupCountX, groupCountY, groupCountZ); } #endif #if (defined(VK_HUAWEI_cluster_culling_shader)) - void cmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const noexcept { + void + cmdDrawClusterIndirectHUAWEI(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) const noexcept + { fp_vkCmdDrawClusterIndirectHUAWEI(commandBuffer, buffer, offset); } #endif #if (defined(VK_NV_device_generated_commands_compute)) - void cmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) const noexcept { + void cmdUpdatePipelineIndirectBufferNV(VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline) const noexcept + { fp_vkCmdUpdatePipelineIndirectBufferNV(commandBuffer, pipelineBindPoint, pipeline); } #endif - void cmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) const noexcept { + void cmdCopyBuffer(VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions) const noexcept + { fp_vkCmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); } - void cmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) const noexcept { + void cmdCopyImage(VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions) const noexcept + { fp_vkCmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } - void cmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) const noexcept { - fp_vkCmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); - } - void cmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) const noexcept { + void cmdBlitImage(VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkFilter filter) const noexcept + { + fp_vkCmdBlitImage( + commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); + } + void cmdCopyBufferToImage(VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions) const noexcept + { fp_vkCmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); } - void cmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) const noexcept { + void cmdCopyImageToBuffer(VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions) const noexcept + { fp_vkCmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); } #if (defined(VK_NV_copy_memory_indirect)) - void cmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride) const noexcept { + void cmdCopyMemoryIndirectNV(VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride) const noexcept + { fp_vkCmdCopyMemoryIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride); } #endif #if (defined(VK_NV_copy_memory_indirect)) - void cmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, VkDeviceAddress copyBufferAddress, uint32_t copyCount, uint32_t stride, VkImage dstImage, VkImageLayout dstImageLayout, const VkImageSubresourceLayers* pImageSubresources) const noexcept { - fp_vkCmdCopyMemoryToImageIndirectNV(commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources); - } -#endif - void cmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) const noexcept { + void cmdCopyMemoryToImageIndirectNV(VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride, + VkImage dstImage, + VkImageLayout dstImageLayout, + const VkImageSubresourceLayers* pImageSubresources) const noexcept + { + fp_vkCmdCopyMemoryToImageIndirectNV( + commandBuffer, copyBufferAddress, copyCount, stride, dstImage, dstImageLayout, pImageSubresources); + } +#endif + void cmdUpdateBuffer(VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + const void* pData) const noexcept + { fp_vkCmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); } - void cmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) const noexcept { + void cmdFillBuffer(VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize size, + uint32_t data) const noexcept + { fp_vkCmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); } - void cmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) const noexcept { + void cmdClearColorImage(VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges) const noexcept + { fp_vkCmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); } - void cmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) const noexcept { + void cmdClearDepthStencilImage(VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges) const noexcept + { fp_vkCmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); } - void cmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) const noexcept { + void cmdClearAttachments(VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkClearAttachment* pAttachments, + uint32_t rectCount, + const VkClearRect* pRects) const noexcept + { fp_vkCmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); } - void cmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) const noexcept { + void cmdResolveImage(VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions) const noexcept + { fp_vkCmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); } - void cmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const noexcept { + void cmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const noexcept + { fp_vkCmdSetEvent(commandBuffer, event, stageMask); } - void cmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const noexcept { + void cmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) const noexcept + { fp_vkCmdResetEvent(commandBuffer, event, stageMask); } - void cmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const noexcept { - fp_vkCmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); - } - void cmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const VkMemoryBarrier* pMemoryBarriers, uint32_t bufferMemoryBarrierCount, const VkBufferMemoryBarrier* pBufferMemoryBarriers, uint32_t imageMemoryBarrierCount, const VkImageMemoryBarrier* pImageMemoryBarriers) const noexcept { - fp_vkCmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); - } - void cmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) const noexcept { + void cmdWaitEvents(VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers) const noexcept + { + fp_vkCmdWaitEvents(commandBuffer, + eventCount, + pEvents, + srcStageMask, + dstStageMask, + memoryBarrierCount, + pMemoryBarriers, + bufferMemoryBarrierCount, + pBufferMemoryBarriers, + imageMemoryBarrierCount, + pImageMemoryBarriers); + } + void cmdPipelineBarrier(VkCommandBuffer commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers) const noexcept + { + fp_vkCmdPipelineBarrier(commandBuffer, + srcStageMask, + dstStageMask, + dependencyFlags, + memoryBarrierCount, + pMemoryBarriers, + bufferMemoryBarrierCount, + pBufferMemoryBarriers, + imageMemoryBarrierCount, + pImageMemoryBarriers); + } + void cmdBeginQuery(VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags) const noexcept + { fp_vkCmdBeginQuery(commandBuffer, queryPool, query, flags); } - void cmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) const noexcept { + void cmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) const noexcept + { fp_vkCmdEndQuery(commandBuffer, queryPool, query); } #if (defined(VK_EXT_conditional_rendering)) - void cmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) const noexcept { + void + cmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, + const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) const noexcept + { fp_vkCmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); } #endif #if (defined(VK_EXT_conditional_rendering)) - void cmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) const noexcept { + void cmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) const noexcept + { fp_vkCmdEndConditionalRenderingEXT(commandBuffer); } #endif - void cmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const noexcept { + void cmdResetQueryPool(VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount) const noexcept + { fp_vkCmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); } - void cmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) const noexcept { + void cmdWriteTimestamp(VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query) const noexcept + { fp_vkCmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); } - void cmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) const noexcept { - fp_vkCmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); - } - void cmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) const noexcept { + void cmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags) const noexcept + { + fp_vkCmdCopyQueryPoolResults( + commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); + } + void cmdPushConstants(VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void* pValues) const noexcept + { fp_vkCmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); } - void cmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) const noexcept { + void cmdBeginRenderPass(VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkSubpassContents contents) const noexcept + { fp_vkCmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); } - void cmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) const noexcept { + void cmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) const noexcept + { fp_vkCmdNextSubpass(commandBuffer, contents); } - void cmdEndRenderPass(VkCommandBuffer commandBuffer) const noexcept { - fp_vkCmdEndRenderPass(commandBuffer); - } - void cmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) const noexcept { + void cmdEndRenderPass(VkCommandBuffer commandBuffer) const noexcept { fp_vkCmdEndRenderPass(commandBuffer); } + void cmdExecuteCommands(VkCommandBuffer commandBuffer, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers) const noexcept + { fp_vkCmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); } #if (defined(VK_KHR_display_swapchain)) - VkResult createSharedSwapchainsKHR(uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) const noexcept { + VkResult createSharedSwapchainsKHR(uint32_t swapchainCount, + const VkSwapchainCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchains) const noexcept + { return fp_vkCreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); } #endif #if (defined(VK_KHR_swapchain)) - VkResult createSwapchainKHR(const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) const noexcept { + VkResult createSwapchainKHR(const VkSwapchainCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchain) const noexcept + { return fp_vkCreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); } #endif #if (defined(VK_KHR_swapchain)) - void destroySwapchainKHR(VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroySwapchainKHR(VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroySwapchainKHR(device, swapchain, pAllocator); } #endif #if (defined(VK_KHR_swapchain)) - VkResult getSwapchainImagesKHR(VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) const noexcept { + VkResult getSwapchainImagesKHR(VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, + VkImage* pSwapchainImages) const noexcept + { return fp_vkGetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); } #endif #if (defined(VK_KHR_swapchain)) - VkResult acquireNextImageKHR(VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) const noexcept { + VkResult acquireNextImageKHR(VkSwapchainKHR swapchain, + uint64_t timeout, + VkSemaphore semaphore, + VkFence fence, + uint32_t* pImageIndex) const noexcept + { return fp_vkAcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); } #endif #if (defined(VK_KHR_swapchain)) - VkResult queuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) const noexcept { + VkResult queuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) const noexcept + { return fp_vkQueuePresentKHR(queue, pPresentInfo); } #endif #if (defined(VK_EXT_debug_marker)) - VkResult debugMarkerSetObjectNameEXT(const VkDebugMarkerObjectNameInfoEXT* pNameInfo) const noexcept { + VkResult debugMarkerSetObjectNameEXT(const VkDebugMarkerObjectNameInfoEXT* pNameInfo) const noexcept + { return fp_vkDebugMarkerSetObjectNameEXT(device, pNameInfo); } #endif #if (defined(VK_EXT_debug_marker)) - VkResult debugMarkerSetObjectTagEXT(const VkDebugMarkerObjectTagInfoEXT* pTagInfo) const noexcept { + VkResult debugMarkerSetObjectTagEXT(const VkDebugMarkerObjectTagInfoEXT* pTagInfo) const noexcept + { return fp_vkDebugMarkerSetObjectTagEXT(device, pTagInfo); } #endif #if (defined(VK_EXT_debug_marker)) - void cmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const noexcept { + void cmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const noexcept + { fp_vkCmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); } #endif #if (defined(VK_EXT_debug_marker)) - void cmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) const noexcept { + void cmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) const noexcept + { fp_vkCmdDebugMarkerEndEXT(commandBuffer); } #endif #if (defined(VK_EXT_debug_marker)) - void cmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const noexcept { + void cmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const noexcept + { fp_vkCmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); } #endif #if (defined(VK_NV_external_memory_win32)) - VkResult getMemoryWin32HandleNV(VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) const noexcept { + VkResult getMemoryWin32HandleNV(VkDeviceMemory memory, + VkExternalMemoryHandleTypeFlagsNV handleType, + HANDLE* pHandle) const noexcept + { return fp_vkGetMemoryWin32HandleNV(device, memory, handleType, pHandle); } #endif #if (defined(VK_NV_device_generated_commands)) - void cmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) const noexcept { + void cmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) const noexcept + { fp_vkCmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo); } #endif #if (defined(VK_NV_device_generated_commands)) - void cmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) const noexcept { + void cmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) const noexcept + { fp_vkCmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo); } #endif #if (defined(VK_NV_device_generated_commands)) - void cmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) const noexcept { + void cmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline, + uint32_t groupIndex) const noexcept + { fp_vkCmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex); } #endif #if (defined(VK_NV_device_generated_commands)) - void getGeneratedCommandsMemoryRequirementsNV(const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept { + void getGeneratedCommandsMemoryRequirementsNV(const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept + { fp_vkGetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements); } #endif #if (defined(VK_NV_device_generated_commands)) - VkResult createIndirectCommandsLayoutNV(const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) const noexcept { + VkResult createIndirectCommandsLayoutNV(const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) const noexcept + { return fp_vkCreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); } #endif #if (defined(VK_NV_device_generated_commands)) - void destroyIndirectCommandsLayoutNV(VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyIndirectCommandsLayoutNV(VkIndirectCommandsLayoutNV indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator); } #endif #if (defined(VK_EXT_device_generated_commands)) - void cmdExecuteGeneratedCommandsEXT(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) const noexcept { + void cmdExecuteGeneratedCommandsEXT(VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo) const noexcept + { fp_vkCmdExecuteGeneratedCommandsEXT(commandBuffer, isPreprocessed, pGeneratedCommandsInfo); } #endif #if (defined(VK_EXT_device_generated_commands)) - void cmdPreprocessGeneratedCommandsEXT(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, VkCommandBuffer stateCommandBuffer) const noexcept { + void cmdPreprocessGeneratedCommandsEXT(VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoEXT* pGeneratedCommandsInfo, + VkCommandBuffer stateCommandBuffer) const noexcept + { fp_vkCmdPreprocessGeneratedCommandsEXT(commandBuffer, pGeneratedCommandsInfo, stateCommandBuffer); } #endif #if (defined(VK_EXT_device_generated_commands)) - void getGeneratedCommandsMemoryRequirementsEXT(const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept { + void getGeneratedCommandsMemoryRequirementsEXT(const VkGeneratedCommandsMemoryRequirementsInfoEXT* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept + { fp_vkGetGeneratedCommandsMemoryRequirementsEXT(device, pInfo, pMemoryRequirements); } #endif #if (defined(VK_EXT_device_generated_commands)) - VkResult createIndirectCommandsLayoutEXT(const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout) const noexcept { + VkResult createIndirectCommandsLayoutEXT(const VkIndirectCommandsLayoutCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutEXT* pIndirectCommandsLayout) const noexcept + { return fp_vkCreateIndirectCommandsLayoutEXT(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); } #endif #if (defined(VK_EXT_device_generated_commands)) - void destroyIndirectCommandsLayoutEXT(VkIndirectCommandsLayoutEXT indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyIndirectCommandsLayoutEXT(VkIndirectCommandsLayoutEXT indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyIndirectCommandsLayoutEXT(device, indirectCommandsLayout, pAllocator); } #endif #if (defined(VK_EXT_device_generated_commands)) - VkResult createIndirectExecutionSetEXT(const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectExecutionSetEXT* pIndirectExecutionSet) const noexcept { + VkResult createIndirectExecutionSetEXT(const VkIndirectExecutionSetCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectExecutionSetEXT* pIndirectExecutionSet) const noexcept + { return fp_vkCreateIndirectExecutionSetEXT(device, pCreateInfo, pAllocator, pIndirectExecutionSet); } #endif #if (defined(VK_EXT_device_generated_commands)) - void destroyIndirectExecutionSetEXT(VkIndirectExecutionSetEXT indirectExecutionSet, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyIndirectExecutionSetEXT(VkIndirectExecutionSetEXT indirectExecutionSet, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyIndirectExecutionSetEXT(device, indirectExecutionSet, pAllocator); } #endif #if (defined(VK_EXT_device_generated_commands)) - void updateIndirectExecutionSetPipelineEXT(VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites) const noexcept { - fp_vkUpdateIndirectExecutionSetPipelineEXT(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); + void updateIndirectExecutionSetPipelineEXT( + VkIndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetPipelineEXT* pExecutionSetWrites) const noexcept + { + fp_vkUpdateIndirectExecutionSetPipelineEXT( + device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); } #endif #if (defined(VK_EXT_device_generated_commands)) - void updateIndirectExecutionSetShaderEXT(VkIndirectExecutionSetEXT indirectExecutionSet, uint32_t executionSetWriteCount, const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites) const noexcept { - fp_vkUpdateIndirectExecutionSetShaderEXT(device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); + void + updateIndirectExecutionSetShaderEXT(VkIndirectExecutionSetEXT indirectExecutionSet, + uint32_t executionSetWriteCount, + const VkWriteIndirectExecutionSetShaderEXT* pExecutionSetWrites) const noexcept + { + fp_vkUpdateIndirectExecutionSetShaderEXT( + device, indirectExecutionSet, executionSetWriteCount, pExecutionSetWrites); } #endif #if (defined(VK_KHR_push_descriptor)) - void cmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) const noexcept { - fp_vkCmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); + void cmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites) const noexcept + { + fp_vkCmdPushDescriptorSetKHR( + commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); } #endif #if (defined(VK_VERSION_1_1)) - void trimCommandPool(VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags) const noexcept { + void trimCommandPool(VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags) const noexcept + { fp_vkTrimCommandPool(device, commandPool, flags); } #endif #if (defined(VK_KHR_external_memory_win32)) - VkResult getMemoryWin32HandleKHR(const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) const noexcept { + VkResult getMemoryWin32HandleKHR(const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle) const noexcept + { return fp_vkGetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); } #endif #if (defined(VK_KHR_external_memory_win32)) - VkResult getMemoryWin32HandlePropertiesKHR(VkExternalMemoryHandleTypeFlagBitsKHR handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) const noexcept { + VkResult + getMemoryWin32HandlePropertiesKHR(VkExternalMemoryHandleTypeFlagBitsKHR handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) const noexcept + { return fp_vkGetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties); } #endif #if (defined(VK_KHR_external_memory_fd)) - VkResult getMemoryFdKHR(const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) const noexcept { + VkResult getMemoryFdKHR(const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) const noexcept + { return fp_vkGetMemoryFdKHR(device, pGetFdInfo, pFd); } #endif #if (defined(VK_KHR_external_memory_fd)) - VkResult getMemoryFdPropertiesKHR(VkExternalMemoryHandleTypeFlagBitsKHR handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) const noexcept { + VkResult getMemoryFdPropertiesKHR(VkExternalMemoryHandleTypeFlagBitsKHR handleType, + int fd, + VkMemoryFdPropertiesKHR* pMemoryFdProperties) const noexcept + { return fp_vkGetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); } #endif #if (defined(VK_FUCHSIA_external_memory)) - VkResult getMemoryZirconHandleFUCHSIA(const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) const noexcept { + VkResult getMemoryZirconHandleFUCHSIA(const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, + zx_handle_t* pZirconHandle) const noexcept + { return fp_vkGetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle); } #endif #if (defined(VK_FUCHSIA_external_memory)) - VkResult getMemoryZirconHandlePropertiesFUCHSIA(VkExternalMemoryHandleTypeFlagBitsKHR handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) const noexcept { - return fp_vkGetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, zirconHandle, pMemoryZirconHandleProperties); + VkResult getMemoryZirconHandlePropertiesFUCHSIA( + VkExternalMemoryHandleTypeFlagBitsKHR handleType, + zx_handle_t zirconHandle, + VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) const noexcept + { + return fp_vkGetMemoryZirconHandlePropertiesFUCHSIA( + device, handleType, zirconHandle, pMemoryZirconHandleProperties); } #endif #if (defined(VK_NV_external_memory_rdma)) - VkResult getMemoryRemoteAddressNV(const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress) const noexcept { + VkResult getMemoryRemoteAddressNV(const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, + VkRemoteAddressNV* pAddress) const noexcept + { return fp_vkGetMemoryRemoteAddressNV(device, pMemoryGetRemoteAddressInfo, pAddress); } #endif #if (defined(VK_NV_external_memory_sci_buf)) - VkResult getMemorySciBufNV(const VkMemoryGetSciBufInfoNV* pGetSciBufInfo, NvSciBufObj* pHandle) const noexcept { + VkResult getMemorySciBufNV(const VkMemoryGetSciBufInfoNV* pGetSciBufInfo, NvSciBufObj* pHandle) const noexcept + { return fp_vkGetMemorySciBufNV(device, pGetSciBufInfo, pHandle); } #endif #if (defined(VK_KHR_external_semaphore_win32)) - VkResult getSemaphoreWin32HandleKHR(const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) const noexcept { + VkResult getSemaphoreWin32HandleKHR(const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle) const noexcept + { return fp_vkGetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); } #endif #if (defined(VK_KHR_external_semaphore_win32)) - VkResult importSemaphoreWin32HandleKHR(const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) const noexcept { + VkResult importSemaphoreWin32HandleKHR( + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) const noexcept + { return fp_vkImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); } #endif #if (defined(VK_KHR_external_semaphore_fd)) - VkResult getSemaphoreFdKHR(const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) const noexcept { + VkResult getSemaphoreFdKHR(const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) const noexcept + { return fp_vkGetSemaphoreFdKHR(device, pGetFdInfo, pFd); } #endif #if (defined(VK_KHR_external_semaphore_fd)) - VkResult importSemaphoreFdKHR(const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) const noexcept { + VkResult importSemaphoreFdKHR(const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) const noexcept + { return fp_vkImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); } #endif #if (defined(VK_FUCHSIA_external_semaphore)) - VkResult getSemaphoreZirconHandleFUCHSIA(const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) const noexcept { + VkResult getSemaphoreZirconHandleFUCHSIA(const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, + zx_handle_t* pZirconHandle) const noexcept + { return fp_vkGetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle); } #endif #if (defined(VK_FUCHSIA_external_semaphore)) - VkResult importSemaphoreZirconHandleFUCHSIA(const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) const noexcept { + VkResult importSemaphoreZirconHandleFUCHSIA( + const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) const noexcept + { return fp_vkImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo); } #endif #if (defined(VK_KHR_external_fence_win32)) - VkResult getFenceWin32HandleKHR(const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) const noexcept { + VkResult getFenceWin32HandleKHR(const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle) const noexcept + { return fp_vkGetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); } #endif #if (defined(VK_KHR_external_fence_win32)) - VkResult importFenceWin32HandleKHR(const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) const noexcept { + VkResult + importFenceWin32HandleKHR(const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) const noexcept + { return fp_vkImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); } #endif #if (defined(VK_KHR_external_fence_fd)) - VkResult getFenceFdKHR(const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) const noexcept { + VkResult getFenceFdKHR(const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) const noexcept + { return fp_vkGetFenceFdKHR(device, pGetFdInfo, pFd); } #endif #if (defined(VK_KHR_external_fence_fd)) - VkResult importFenceFdKHR(const VkImportFenceFdInfoKHR* pImportFenceFdInfo) const noexcept { + VkResult importFenceFdKHR(const VkImportFenceFdInfoKHR* pImportFenceFdInfo) const noexcept + { return fp_vkImportFenceFdKHR(device, pImportFenceFdInfo); } #endif #if (defined(VK_NV_external_sci_sync)) || (defined(VK_NV_external_sci_sync2)) - VkResult getFenceSciSyncFenceNV(const VkFenceGetSciSyncInfoNV* pGetSciSyncHandleInfo, void* pHandle) const noexcept { + VkResult getFenceSciSyncFenceNV(const VkFenceGetSciSyncInfoNV* pGetSciSyncHandleInfo, void* pHandle) const noexcept + { return fp_vkGetFenceSciSyncFenceNV(device, pGetSciSyncHandleInfo, pHandle); } #endif #if (defined(VK_NV_external_sci_sync)) || (defined(VK_NV_external_sci_sync2)) - VkResult getFenceSciSyncObjNV(const VkFenceGetSciSyncInfoNV* pGetSciSyncHandleInfo, void* pHandle) const noexcept { + VkResult getFenceSciSyncObjNV(const VkFenceGetSciSyncInfoNV* pGetSciSyncHandleInfo, void* pHandle) const noexcept + { return fp_vkGetFenceSciSyncObjNV(device, pGetSciSyncHandleInfo, pHandle); } #endif #if (defined(VK_NV_external_sci_sync)) || (defined(VK_NV_external_sci_sync2)) - VkResult importFenceSciSyncFenceNV(const VkImportFenceSciSyncInfoNV* pImportFenceSciSyncInfo) const noexcept { + VkResult importFenceSciSyncFenceNV(const VkImportFenceSciSyncInfoNV* pImportFenceSciSyncInfo) const noexcept + { return fp_vkImportFenceSciSyncFenceNV(device, pImportFenceSciSyncInfo); } #endif #if (defined(VK_NV_external_sci_sync)) || (defined(VK_NV_external_sci_sync2)) - VkResult importFenceSciSyncObjNV(const VkImportFenceSciSyncInfoNV* pImportFenceSciSyncInfo) const noexcept { + VkResult importFenceSciSyncObjNV(const VkImportFenceSciSyncInfoNV* pImportFenceSciSyncInfo) const noexcept + { return fp_vkImportFenceSciSyncObjNV(device, pImportFenceSciSyncInfo); } #endif #if (defined(VK_NV_external_sci_sync)) - VkResult getSemaphoreSciSyncObjNV(const VkSemaphoreGetSciSyncInfoNV* pGetSciSyncInfo, void* pHandle) const noexcept { + VkResult getSemaphoreSciSyncObjNV(const VkSemaphoreGetSciSyncInfoNV* pGetSciSyncInfo, void* pHandle) const noexcept + { return fp_vkGetSemaphoreSciSyncObjNV(device, pGetSciSyncInfo, pHandle); } #endif #if (defined(VK_NV_external_sci_sync)) - VkResult importSemaphoreSciSyncObjNV(const VkImportSemaphoreSciSyncInfoNV* pImportSemaphoreSciSyncInfo) const noexcept { + VkResult + importSemaphoreSciSyncObjNV(const VkImportSemaphoreSciSyncInfoNV* pImportSemaphoreSciSyncInfo) const noexcept + { return fp_vkImportSemaphoreSciSyncObjNV(device, pImportSemaphoreSciSyncInfo); } #endif #if (defined(VK_NV_external_sci_sync2)) - VkResult createSemaphoreSciSyncPoolNV(const VkSemaphoreSciSyncPoolCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphoreSciSyncPoolNV* pSemaphorePool) const noexcept { + VkResult createSemaphoreSciSyncPoolNV(const VkSemaphoreSciSyncPoolCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSemaphoreSciSyncPoolNV* pSemaphorePool) const noexcept + { return fp_vkCreateSemaphoreSciSyncPoolNV(device, pCreateInfo, pAllocator, pSemaphorePool); } #endif #if (defined(VK_NV_external_sci_sync2)) - void destroySemaphoreSciSyncPoolNV(VkSemaphoreSciSyncPoolNV semaphorePool, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroySemaphoreSciSyncPoolNV(VkSemaphoreSciSyncPoolNV semaphorePool, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroySemaphoreSciSyncPoolNV(device, semaphorePool, pAllocator); } #endif #if (defined(VK_EXT_display_control)) - VkResult displayPowerControlEXT(VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) const noexcept { + VkResult displayPowerControlEXT(VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) const noexcept + { return fp_vkDisplayPowerControlEXT(device, display, pDisplayPowerInfo); } #endif #if (defined(VK_EXT_display_control)) - VkResult registerDeviceEventEXT(const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const noexcept { + VkResult registerDeviceEventEXT(const VkDeviceEventInfoEXT* pDeviceEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence) const noexcept + { return fp_vkRegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence); } #endif #if (defined(VK_EXT_display_control)) - VkResult registerDisplayEventEXT(VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) const noexcept { + VkResult registerDisplayEventEXT(VkDisplayKHR display, + const VkDisplayEventInfoEXT* pDisplayEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence) const noexcept + { return fp_vkRegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence); } #endif #if (defined(VK_EXT_display_control)) - VkResult getSwapchainCounterEXT(VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) const noexcept { + VkResult getSwapchainCounterEXT(VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT counter, + uint64_t* pCounterValue) const noexcept + { return fp_vkGetSwapchainCounterEXT(device, swapchain, counter, pCounterValue); } #endif #if (defined(VK_VERSION_1_1)) - void getDeviceGroupPeerMemoryFeatures(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlagsKHR* pPeerMemoryFeatures) const noexcept { - fp_vkGetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); + void getDeviceGroupPeerMemoryFeatures(uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlagsKHR* pPeerMemoryFeatures) const noexcept + { + fp_vkGetDeviceGroupPeerMemoryFeatures( + device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); } #endif #if (defined(VK_VERSION_1_1)) - VkResult bindBufferMemory2(uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHR* pBindInfos) const noexcept { + VkResult bindBufferMemory2(uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHR* pBindInfos) const noexcept + { return fp_vkBindBufferMemory2(device, bindInfoCount, pBindInfos); } #endif #if (defined(VK_VERSION_1_1)) - VkResult bindImageMemory2(uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos) const noexcept { + VkResult bindImageMemory2(uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos) const noexcept + { return fp_vkBindImageMemory2(device, bindInfoCount, pBindInfos); } #endif #if (defined(VK_VERSION_1_1)) - void cmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) const noexcept { + void cmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) const noexcept + { fp_vkCmdSetDeviceMask(commandBuffer, deviceMask); } #endif #if (defined(VK_KHR_swapchain)) || (defined(VK_KHR_device_group)) - VkResult getDeviceGroupPresentCapabilitiesKHR(VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) const noexcept { + VkResult getDeviceGroupPresentCapabilitiesKHR( + VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) const noexcept + { return fp_vkGetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); } #endif #if (defined(VK_KHR_swapchain)) || (defined(VK_KHR_device_group)) - VkResult getDeviceGroupSurfacePresentModesKHR(VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) const noexcept { + VkResult getDeviceGroupSurfacePresentModesKHR(VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR* pModes) const noexcept + { return fp_vkGetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); } #endif #if (defined(VK_KHR_swapchain)) || (defined(VK_KHR_device_group)) - VkResult acquireNextImage2KHR(const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) const noexcept { + VkResult acquireNextImage2KHR(const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) const noexcept + { return fp_vkAcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); } #endif #if (defined(VK_VERSION_1_1)) - void cmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const noexcept { + void cmdDispatchBase(VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ) const noexcept + { fp_vkCmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); } #endif #if (defined(VK_VERSION_1_1)) - VkResult createDescriptorUpdateTemplate(const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate) const noexcept { + VkResult createDescriptorUpdateTemplate(const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate) const noexcept + { return fp_vkCreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); } #endif #if (defined(VK_VERSION_1_1)) - void destroyDescriptorUpdateTemplate(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyDescriptorUpdateTemplate(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); } #endif #if (defined(VK_VERSION_1_1)) - void updateDescriptorSetWithTemplate(VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData) const noexcept { + void updateDescriptorSetWithTemplate(VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + const void* pData) const noexcept + { fp_vkUpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); } #endif #if (defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_descriptor_update_template)) - void cmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) const noexcept { + void cmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + VkPipelineLayout layout, + uint32_t set, + const void* pData) const noexcept + { fp_vkCmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); } #endif #if (defined(VK_EXT_hdr_metadata)) - void setHdrMetadataEXT(uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) const noexcept { + void setHdrMetadataEXT(uint32_t swapchainCount, + const VkSwapchainKHR* pSwapchains, + const VkHdrMetadataEXT* pMetadata) const noexcept + { fp_vkSetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); } #endif #if (defined(VK_KHR_shared_presentable_image)) - VkResult getSwapchainStatusKHR(VkSwapchainKHR swapchain) const noexcept { + VkResult getSwapchainStatusKHR(VkSwapchainKHR swapchain) const noexcept + { return fp_vkGetSwapchainStatusKHR(device, swapchain); } #endif #if (defined(VK_GOOGLE_display_timing)) - VkResult getRefreshCycleDurationGOOGLE(VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) const noexcept { + VkResult getRefreshCycleDurationGOOGLE(VkSwapchainKHR swapchain, + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) const noexcept + { return fp_vkGetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties); } #endif #if (defined(VK_GOOGLE_display_timing)) - VkResult getPastPresentationTimingGOOGLE(VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) const noexcept { + VkResult getPastPresentationTimingGOOGLE(VkSwapchainKHR swapchain, + uint32_t* pPresentationTimingCount, + VkPastPresentationTimingGOOGLE* pPresentationTimings) const noexcept + { return fp_vkGetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings); } #endif #if (defined(VK_NV_clip_space_w_scaling)) - void cmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) const noexcept { + void cmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportWScalingNV* pViewportWScalings) const noexcept + { fp_vkCmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); } #endif #if (defined(VK_EXT_discard_rectangles)) - void cmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) const noexcept { + void cmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, + uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, + const VkRect2D* pDiscardRectangles) const noexcept + { fp_vkCmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); } #endif #if ((defined(VK_EXT_discard_rectangles))) && VK_HEADER_VERSION >= 241 - void cmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) const noexcept { + void cmdSetDiscardRectangleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 discardRectangleEnable) const noexcept + { fp_vkCmdSetDiscardRectangleEnableEXT(commandBuffer, discardRectangleEnable); } #endif #if ((defined(VK_EXT_discard_rectangles))) && VK_HEADER_VERSION >= 241 - void cmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, VkDiscardRectangleModeEXT discardRectangleMode) const noexcept { + void cmdSetDiscardRectangleModeEXT(VkCommandBuffer commandBuffer, + VkDiscardRectangleModeEXT discardRectangleMode) const noexcept + { fp_vkCmdSetDiscardRectangleModeEXT(commandBuffer, discardRectangleMode); } #endif #if (defined(VK_EXT_sample_locations)) - void cmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) const noexcept { + void cmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, + const VkSampleLocationsInfoEXT* pSampleLocationsInfo) const noexcept + { fp_vkCmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); } #endif #if (defined(VK_VERSION_1_1)) - void getBufferMemoryRequirements2(const VkBufferMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept { + void getBufferMemoryRequirements2(const VkBufferMemoryRequirementsInfo2KHR* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept + { fp_vkGetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); } #endif #if (defined(VK_VERSION_1_1)) - void getImageMemoryRequirements2(const VkImageMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept { + void getImageMemoryRequirements2(const VkImageMemoryRequirementsInfo2KHR* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept + { fp_vkGetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); } #endif #if (defined(VK_VERSION_1_1)) - void getImageSparseMemoryRequirements2(const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements) const noexcept { + void + getImageSparseMemoryRequirements2(const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements) const noexcept + { fp_vkGetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } #endif #if (defined(VK_VERSION_1_3)) - void getDeviceBufferMemoryRequirements(const VkDeviceBufferMemoryRequirementsKHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept { + void getDeviceBufferMemoryRequirements(const VkDeviceBufferMemoryRequirementsKHR* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept + { fp_vkGetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); } #endif #if (defined(VK_VERSION_1_3)) - void getDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirementsKHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept { + void getDeviceImageMemoryRequirements(const VkDeviceImageMemoryRequirementsKHR* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept + { fp_vkGetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); } #endif #if (defined(VK_VERSION_1_3)) - void getDeviceImageSparseMemoryRequirements(const VkDeviceImageMemoryRequirementsKHR* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements) const noexcept { - fp_vkGetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + void getDeviceImageSparseMemoryRequirements( + const VkDeviceImageMemoryRequirementsKHR* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements) const noexcept + { + fp_vkGetDeviceImageSparseMemoryRequirements( + device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } #endif #if (defined(VK_VERSION_1_1)) - VkResult createSamplerYcbcrConversion(const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversionKHR* pYcbcrConversion) const noexcept { + VkResult createSamplerYcbcrConversion(const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversionKHR* pYcbcrConversion) const noexcept + { return fp_vkCreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); } #endif #if (defined(VK_VERSION_1_1)) - void destroySamplerYcbcrConversion(VkSamplerYcbcrConversionKHR ycbcrConversion, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroySamplerYcbcrConversion(VkSamplerYcbcrConversionKHR ycbcrConversion, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); } #endif #if (defined(VK_VERSION_1_1)) - void getDeviceQueue2(const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) const noexcept { + void getDeviceQueue2(const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) const noexcept + { fp_vkGetDeviceQueue2(device, pQueueInfo, pQueue); } #endif #if (defined(VK_EXT_validation_cache)) - VkResult createValidationCacheEXT(const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) const noexcept { + VkResult createValidationCacheEXT(const VkValidationCacheCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkValidationCacheEXT* pValidationCache) const noexcept + { return fp_vkCreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache); } #endif #if (defined(VK_EXT_validation_cache)) - void destroyValidationCacheEXT(VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyValidationCacheEXT(VkValidationCacheEXT validationCache, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyValidationCacheEXT(device, validationCache, pAllocator); } #endif #if (defined(VK_EXT_validation_cache)) - VkResult getValidationCacheDataEXT(VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) const noexcept { + VkResult + getValidationCacheDataEXT(VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) const noexcept + { return fp_vkGetValidationCacheDataEXT(device, validationCache, pDataSize, pData); } #endif #if (defined(VK_EXT_validation_cache)) - VkResult mergeValidationCachesEXT(VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) const noexcept { + VkResult mergeValidationCachesEXT(VkValidationCacheEXT dstCache, + uint32_t srcCacheCount, + const VkValidationCacheEXT* pSrcCaches) const noexcept + { return fp_vkMergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches); } #endif #if (defined(VK_VERSION_1_1)) - void getDescriptorSetLayoutSupport(const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupportKHR* pSupport) const noexcept { + void getDescriptorSetLayoutSupport(const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupportKHR* pSupport) const noexcept + { fp_vkGetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); } #endif #if (defined(VK_ANDROID_native_buffer)) - VkResult getSwapchainGrallocUsageANDROID(VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage) const noexcept { + VkResult + getSwapchainGrallocUsageANDROID(VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage) const noexcept + { return fp_vkGetSwapchainGrallocUsageANDROID(device, format, imageUsage, grallocUsage); } #endif #if (defined(VK_ANDROID_native_buffer)) - VkResult getSwapchainGrallocUsage2ANDROID(VkFormat format, VkImageUsageFlags imageUsage, VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage, uint64_t* grallocProducerUsage) const noexcept { - return fp_vkGetSwapchainGrallocUsage2ANDROID(device, format, imageUsage, swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage); + VkResult getSwapchainGrallocUsage2ANDROID(VkFormat format, + VkImageUsageFlags imageUsage, + VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, + uint64_t* grallocConsumerUsage, + uint64_t* grallocProducerUsage) const noexcept + { + return fp_vkGetSwapchainGrallocUsage2ANDROID( + device, format, imageUsage, swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage); } #endif #if (defined(VK_ANDROID_native_buffer)) - VkResult acquireImageANDROID(VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence) const noexcept { + VkResult acquireImageANDROID(VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence) const noexcept + { return fp_vkAcquireImageANDROID(device, image, nativeFenceFd, semaphore, fence); } #endif #if (defined(VK_ANDROID_native_buffer)) - VkResult queueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int* pNativeFenceFd) const noexcept { + VkResult queueSignalReleaseImageANDROID(VkQueue queue, + uint32_t waitSemaphoreCount, + const VkSemaphore* pWaitSemaphores, + VkImage image, + int* pNativeFenceFd) const noexcept + { return fp_vkQueueSignalReleaseImageANDROID(queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd); } #endif #if (defined(VK_AMD_shader_info)) - VkResult getShaderInfoAMD(VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) const noexcept { + VkResult getShaderInfoAMD(VkPipeline pipeline, + VkShaderStageFlagBits shaderStage, + VkShaderInfoTypeAMD infoType, + size_t* pInfoSize, + void* pInfo) const noexcept + { return fp_vkGetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo); } #endif #if (defined(VK_AMD_display_native_hdr)) - void setLocalDimmingAMD(VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) const noexcept { + void setLocalDimmingAMD(VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) const noexcept + { fp_vkSetLocalDimmingAMD(device, swapChain, localDimmingEnable); } #endif #if (defined(VK_KHR_calibrated_timestamps)) - VkResult getCalibratedTimestampsKHR(uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) const noexcept { + VkResult getCalibratedTimestampsKHR(uint32_t timestampCount, + const VkCalibratedTimestampInfoEXT* pTimestampInfos, + uint64_t* pTimestamps, + uint64_t* pMaxDeviation) const noexcept + { return fp_vkGetCalibratedTimestampsKHR(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); } #endif #if (defined(VK_EXT_debug_utils)) - VkResult setDebugUtilsObjectNameEXT(const VkDebugUtilsObjectNameInfoEXT* pNameInfo) const noexcept { + VkResult setDebugUtilsObjectNameEXT(const VkDebugUtilsObjectNameInfoEXT* pNameInfo) const noexcept + { return fp_vkSetDebugUtilsObjectNameEXT(device, pNameInfo); } #endif #if (defined(VK_EXT_debug_utils)) - VkResult setDebugUtilsObjectTagEXT(const VkDebugUtilsObjectTagInfoEXT* pTagInfo) const noexcept { + VkResult setDebugUtilsObjectTagEXT(const VkDebugUtilsObjectTagInfoEXT* pTagInfo) const noexcept + { return fp_vkSetDebugUtilsObjectTagEXT(device, pTagInfo); } #endif #if (defined(VK_EXT_debug_utils)) - void queueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) const noexcept { + void queueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) const noexcept + { fp_vkQueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); } #endif #if (defined(VK_EXT_debug_utils)) - void queueEndDebugUtilsLabelEXT(VkQueue queue) const noexcept { - fp_vkQueueEndDebugUtilsLabelEXT(queue); - } + void queueEndDebugUtilsLabelEXT(VkQueue queue) const noexcept { fp_vkQueueEndDebugUtilsLabelEXT(queue); } #endif #if (defined(VK_EXT_debug_utils)) - void queueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) const noexcept { + void queueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) const noexcept + { fp_vkQueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); } #endif #if (defined(VK_EXT_debug_utils)) - void cmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) const noexcept { + void cmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo) const noexcept + { fp_vkCmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); } #endif #if (defined(VK_EXT_debug_utils)) - void cmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) const noexcept { + void cmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) const noexcept + { fp_vkCmdEndDebugUtilsLabelEXT(commandBuffer); } #endif #if (defined(VK_EXT_debug_utils)) - void cmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) const noexcept { + void cmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo) const noexcept + { fp_vkCmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); } #endif #if (defined(VK_EXT_external_memory_host)) - VkResult getMemoryHostPointerPropertiesEXT(VkExternalMemoryHandleTypeFlagBitsKHR handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) const noexcept { + VkResult + getMemoryHostPointerPropertiesEXT(VkExternalMemoryHandleTypeFlagBitsKHR handleType, + const void* pHostPointer, + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) const noexcept + { return fp_vkGetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties); } #endif #if (defined(VK_AMD_buffer_marker)) - void cmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const noexcept { + void cmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker) const noexcept + { fp_vkCmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); } #endif #if (defined(VK_VERSION_1_2)) - VkResult createRenderPass2(const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) const noexcept { + VkResult createRenderPass2(const VkRenderPassCreateInfo2KHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass) const noexcept + { return fp_vkCreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass); } #endif #if (defined(VK_VERSION_1_2)) - void cmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo) const noexcept { + void cmdBeginRenderPass2(VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfoKHR* pSubpassBeginInfo) const noexcept + { fp_vkCmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); } #endif #if (defined(VK_VERSION_1_2)) - void cmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo) const noexcept { + void cmdNextSubpass2(VkCommandBuffer commandBuffer, + const VkSubpassBeginInfoKHR* pSubpassBeginInfo, + const VkSubpassEndInfoKHR* pSubpassEndInfo) const noexcept + { fp_vkCmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); } #endif #if (defined(VK_VERSION_1_2)) - void cmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo) const noexcept { + void cmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo) const noexcept + { fp_vkCmdEndRenderPass2(commandBuffer, pSubpassEndInfo); } #endif #if (defined(VK_VERSION_1_2)) - VkResult getSemaphoreCounterValue(VkSemaphore semaphore, uint64_t* pValue) const noexcept { + VkResult getSemaphoreCounterValue(VkSemaphore semaphore, uint64_t* pValue) const noexcept + { return fp_vkGetSemaphoreCounterValue(device, semaphore, pValue); } #endif #if (defined(VK_VERSION_1_2)) - VkResult waitSemaphores(const VkSemaphoreWaitInfoKHR* pWaitInfo, uint64_t timeout) const noexcept { + VkResult waitSemaphores(const VkSemaphoreWaitInfoKHR* pWaitInfo, uint64_t timeout) const noexcept + { return fp_vkWaitSemaphores(device, pWaitInfo, timeout); } #endif #if (defined(VK_VERSION_1_2)) - VkResult signalSemaphore(const VkSemaphoreSignalInfoKHR* pSignalInfo) const noexcept { + VkResult signalSemaphore(const VkSemaphoreSignalInfoKHR* pSignalInfo) const noexcept + { return fp_vkSignalSemaphore(device, pSignalInfo); } #endif #if (defined(VK_ANDROID_external_memory_android_hardware_buffer)) - VkResult getAndroidHardwareBufferPropertiesANDROID(const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) const noexcept { + VkResult + getAndroidHardwareBufferPropertiesANDROID(const struct AHardwareBuffer* buffer, + VkAndroidHardwareBufferPropertiesANDROID* pProperties) const noexcept + { return fp_vkGetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties); } #endif #if (defined(VK_ANDROID_external_memory_android_hardware_buffer)) - VkResult getMemoryAndroidHardwareBufferANDROID(const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer) const noexcept { + VkResult getMemoryAndroidHardwareBufferANDROID(const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, + struct AHardwareBuffer** pBuffer) const noexcept + { return fp_vkGetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer); } #endif #if (defined(VK_VERSION_1_2)) - void cmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const noexcept { + void cmdDrawIndirectCount(VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) const noexcept + { fp_vkCmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } #endif #if (defined(VK_VERSION_1_2)) - void cmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const noexcept { - fp_vkCmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + void cmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) const noexcept + { + fp_vkCmdDrawIndexedIndirectCount( + commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } #endif #if (defined(VK_NV_device_diagnostic_checkpoints)) - void cmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) const noexcept { + void cmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) const noexcept + { fp_vkCmdSetCheckpointNV(commandBuffer, pCheckpointMarker); } #endif #if (defined(VK_NV_device_diagnostic_checkpoints)) - void getQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) const noexcept { + void getQueueCheckpointDataNV(VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointDataNV* pCheckpointData) const noexcept + { fp_vkGetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData); } #endif #if (defined(VK_EXT_transform_feedback)) - void cmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) const noexcept { + void cmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes) const noexcept + { fp_vkCmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); } #endif #if (defined(VK_EXT_transform_feedback)) - void cmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) const noexcept { - fp_vkCmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + void cmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets) const noexcept + { + fp_vkCmdBeginTransformFeedbackEXT( + commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); } #endif #if (defined(VK_EXT_transform_feedback)) - void cmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) const noexcept { - fp_vkCmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + void cmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets) const noexcept + { + fp_vkCmdEndTransformFeedbackEXT( + commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); } #endif #if (defined(VK_EXT_transform_feedback)) - void cmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) const noexcept { + void cmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags, + uint32_t index) const noexcept + { fp_vkCmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); } #endif #if (defined(VK_EXT_transform_feedback)) - void cmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) const noexcept { + void cmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + uint32_t index) const noexcept + { fp_vkCmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); } #endif #if (defined(VK_EXT_transform_feedback)) - void cmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) const noexcept { - fp_vkCmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); + void cmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, + uint32_t instanceCount, + uint32_t firstInstance, + VkBuffer counterBuffer, + VkDeviceSize counterBufferOffset, + uint32_t counterOffset, + uint32_t vertexStride) const noexcept + { + fp_vkCmdDrawIndirectByteCountEXT(commandBuffer, + instanceCount, + firstInstance, + counterBuffer, + counterBufferOffset, + counterOffset, + vertexStride); } #endif #if (defined(VK_NV_scissor_exclusive)) - void cmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) const noexcept { + void cmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkRect2D* pExclusiveScissors) const noexcept + { fp_vkCmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); } #endif #if ((defined(VK_NV_scissor_exclusive))) && VK_HEADER_VERSION >= 241 - void cmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkBool32* pExclusiveScissorEnables) const noexcept { - fp_vkCmdSetExclusiveScissorEnableNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables); + void cmdSetExclusiveScissorEnableNV(VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkBool32* pExclusiveScissorEnables) const noexcept + { + fp_vkCmdSetExclusiveScissorEnableNV( + commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissorEnables); } #endif #if (defined(VK_NV_shading_rate_image)) - void cmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const noexcept { + void cmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, + VkImageView imageView, + VkImageLayout imageLayout) const noexcept + { fp_vkCmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout); } #endif #if (defined(VK_NV_shading_rate_image)) - void cmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) const noexcept { + void cmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkShadingRatePaletteNV* pShadingRatePalettes) const noexcept + { fp_vkCmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); } #endif #if (defined(VK_NV_shading_rate_image)) - void cmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) const noexcept { + void cmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, + VkCoarseSampleOrderTypeNV sampleOrderType, + uint32_t customSampleOrderCount, + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) const noexcept + { fp_vkCmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); } #endif #if (defined(VK_NV_mesh_shader)) - void cmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) const noexcept { + void cmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) const noexcept + { fp_vkCmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask); } #endif #if (defined(VK_NV_mesh_shader)) - void cmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const noexcept { + void cmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) const noexcept + { fp_vkCmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride); } #endif #if (defined(VK_NV_mesh_shader)) - void cmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const noexcept { - fp_vkCmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + void cmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) const noexcept + { + fp_vkCmdDrawMeshTasksIndirectCountNV( + commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } #endif #if (defined(VK_EXT_mesh_shader)) - void cmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const noexcept { + void cmdDrawMeshTasksEXT(VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ) const noexcept + { fp_vkCmdDrawMeshTasksEXT(commandBuffer, groupCountX, groupCountY, groupCountZ); } #endif #if (defined(VK_EXT_mesh_shader)) - void cmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) const noexcept { + void cmdDrawMeshTasksIndirectEXT(VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) const noexcept + { fp_vkCmdDrawMeshTasksIndirectEXT(commandBuffer, buffer, offset, drawCount, stride); } #endif #if (defined(VK_EXT_mesh_shader)) - void cmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const noexcept { - fp_vkCmdDrawMeshTasksIndirectCountEXT(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + void cmdDrawMeshTasksIndirectCountEXT(VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) const noexcept + { + fp_vkCmdDrawMeshTasksIndirectCountEXT( + commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } #endif #if (defined(VK_NV_ray_tracing)) - VkResult compileDeferredNV(VkPipeline pipeline, uint32_t shader) const noexcept { + VkResult compileDeferredNV(VkPipeline pipeline, uint32_t shader) const noexcept + { return fp_vkCompileDeferredNV(device, pipeline, shader); } #endif #if (defined(VK_NV_ray_tracing)) - VkResult createAccelerationStructureNV(const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) const noexcept { + VkResult createAccelerationStructureNV(const VkAccelerationStructureCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureNV* pAccelerationStructure) const noexcept + { return fp_vkCreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure); } #endif #if (defined(VK_HUAWEI_invocation_mask)) - void cmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) const noexcept { + void cmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, + VkImageView imageView, + VkImageLayout imageLayout) const noexcept + { fp_vkCmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout); } #endif #if (defined(VK_KHR_acceleration_structure)) - void destroyAccelerationStructureKHR(VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyAccelerationStructureKHR(VkAccelerationStructureKHR accelerationStructure, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator); } #endif #if (defined(VK_NV_ray_tracing)) - void destroyAccelerationStructureNV(VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyAccelerationStructureNV(VkAccelerationStructureNV accelerationStructure, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyAccelerationStructureNV(device, accelerationStructure, pAllocator); } #endif #if (defined(VK_NV_ray_tracing)) - void getAccelerationStructureMemoryRequirementsNV(const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept { + void getAccelerationStructureMemoryRequirementsNV(const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept + { fp_vkGetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements); } #endif #if (defined(VK_NV_ray_tracing)) - VkResult bindAccelerationStructureMemoryNV(uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) const noexcept { + VkResult bindAccelerationStructureMemoryNV(uint32_t bindInfoCount, + const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) const noexcept + { return fp_vkBindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos); } #endif #if (defined(VK_NV_ray_tracing)) - void cmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeNV mode) const noexcept { + void cmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkCopyAccelerationStructureModeNV mode) const noexcept + { fp_vkCmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode); } #endif #if (defined(VK_KHR_acceleration_structure)) - void cmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) const noexcept { + void cmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureInfoKHR* pInfo) const noexcept + { fp_vkCmdCopyAccelerationStructureKHR(commandBuffer, pInfo); } #endif #if (defined(VK_KHR_acceleration_structure)) - VkResult copyAccelerationStructureKHR(VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo) const noexcept { + VkResult copyAccelerationStructureKHR(VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureInfoKHR* pInfo) const noexcept + { return fp_vkCopyAccelerationStructureKHR(device, deferredOperation, pInfo); } #endif #if (defined(VK_KHR_acceleration_structure)) - void cmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) const noexcept { + void cmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) const noexcept + { fp_vkCmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo); } #endif #if (defined(VK_KHR_acceleration_structure)) - VkResult copyAccelerationStructureToMemoryKHR(VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) const noexcept { + VkResult + copyAccelerationStructureToMemoryKHR(VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) const noexcept + { return fp_vkCopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo); } #endif #if (defined(VK_KHR_acceleration_structure)) - void cmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) const noexcept { + void cmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) const noexcept + { fp_vkCmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo); } #endif #if (defined(VK_KHR_acceleration_structure)) - VkResult copyMemoryToAccelerationStructureKHR(VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) const noexcept { + VkResult + copyMemoryToAccelerationStructureKHR(VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) const noexcept + { return fp_vkCopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo); } #endif #if (defined(VK_KHR_acceleration_structure)) - void cmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) const noexcept { - fp_vkCmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); + void cmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery) const noexcept + { + fp_vkCmdWriteAccelerationStructuresPropertiesKHR( + commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); } #endif #if (defined(VK_NV_ray_tracing)) - void cmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) const noexcept { - fp_vkCmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); + void cmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureNV* pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery) const noexcept + { + fp_vkCmdWriteAccelerationStructuresPropertiesNV( + commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); } #endif #if (defined(VK_NV_ray_tracing)) - void cmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) const noexcept { - fp_vkCmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); + void cmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, + const VkAccelerationStructureInfoNV* pInfo, + VkBuffer instanceData, + VkDeviceSize instanceOffset, + VkBool32 update, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkBuffer scratch, + VkDeviceSize scratchOffset) const noexcept + { + fp_vkCmdBuildAccelerationStructureNV( + commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); } #endif #if (defined(VK_KHR_acceleration_structure)) - VkResult writeAccelerationStructuresPropertiesKHR(uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) const noexcept { - return fp_vkWriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride); + VkResult writeAccelerationStructuresPropertiesKHR(uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride) const noexcept + { + return fp_vkWriteAccelerationStructuresPropertiesKHR( + device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride); } #endif #if (defined(VK_KHR_ray_tracing_pipeline)) - void cmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) const noexcept { - fp_vkCmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth); + void cmdTraceRaysKHR(VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + uint32_t width, + uint32_t height, + uint32_t depth) const noexcept + { + fp_vkCmdTraceRaysKHR(commandBuffer, + pRaygenShaderBindingTable, + pMissShaderBindingTable, + pHitShaderBindingTable, + pCallableShaderBindingTable, + width, + height, + depth); } #endif #if (defined(VK_NV_ray_tracing)) - void cmdTraceRaysNV(VkCommandBuffer commandBuffer, VkBuffer raygenShaderBindingTableBuffer, VkDeviceSize raygenShaderBindingOffset, VkBuffer missShaderBindingTableBuffer, VkDeviceSize missShaderBindingOffset, VkDeviceSize missShaderBindingStride, VkBuffer hitShaderBindingTableBuffer, VkDeviceSize hitShaderBindingOffset, VkDeviceSize hitShaderBindingStride, VkBuffer callableShaderBindingTableBuffer, VkDeviceSize callableShaderBindingOffset, VkDeviceSize callableShaderBindingStride, uint32_t width, uint32_t height, uint32_t depth) const noexcept { - fp_vkCmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); + void cmdTraceRaysNV(VkCommandBuffer commandBuffer, + VkBuffer raygenShaderBindingTableBuffer, + VkDeviceSize raygenShaderBindingOffset, + VkBuffer missShaderBindingTableBuffer, + VkDeviceSize missShaderBindingOffset, + VkDeviceSize missShaderBindingStride, + VkBuffer hitShaderBindingTableBuffer, + VkDeviceSize hitShaderBindingOffset, + VkDeviceSize hitShaderBindingStride, + VkBuffer callableShaderBindingTableBuffer, + VkDeviceSize callableShaderBindingOffset, + VkDeviceSize callableShaderBindingStride, + uint32_t width, + uint32_t height, + uint32_t depth) const noexcept + { + fp_vkCmdTraceRaysNV(commandBuffer, + raygenShaderBindingTableBuffer, + raygenShaderBindingOffset, + missShaderBindingTableBuffer, + missShaderBindingOffset, + missShaderBindingStride, + hitShaderBindingTableBuffer, + hitShaderBindingOffset, + hitShaderBindingStride, + callableShaderBindingTableBuffer, + callableShaderBindingOffset, + callableShaderBindingStride, + width, + height, + depth); } #endif #if (defined(VK_KHR_ray_tracing_pipeline)) - VkResult getRayTracingShaderGroupHandlesKHR(VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) const noexcept { + VkResult getRayTracingShaderGroupHandlesKHR( + VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) const noexcept + { return fp_vkGetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData); } #endif #if (defined(VK_KHR_ray_tracing_pipeline)) - VkResult getRayTracingCaptureReplayShaderGroupHandlesKHR(VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) const noexcept { - return fp_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData); + VkResult getRayTracingCaptureReplayShaderGroupHandlesKHR( + VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) const noexcept + { + return fp_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR( + device, pipeline, firstGroup, groupCount, dataSize, pData); } #endif #if (defined(VK_NV_ray_tracing)) - VkResult getAccelerationStructureHandleNV(VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) const noexcept { + VkResult getAccelerationStructureHandleNV(VkAccelerationStructureNV accelerationStructure, + size_t dataSize, + void* pData) const noexcept + { return fp_vkGetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData); } #endif #if (defined(VK_NV_ray_tracing)) - VkResult createRayTracingPipelinesNV(VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const noexcept { - return fp_vkCreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + VkResult createRayTracingPipelinesNV(VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoNV* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) const noexcept + { + return fp_vkCreateRayTracingPipelinesNV( + device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); } #endif #if (defined(VK_KHR_ray_tracing_pipeline)) - VkResult createRayTracingPipelinesKHR(VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const noexcept { - return fp_vkCreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + VkResult createRayTracingPipelinesKHR(VkDeferredOperationKHR deferredOperation, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) const noexcept + { + return fp_vkCreateRayTracingPipelinesKHR( + device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); } #endif #if (defined(VK_KHR_ray_tracing_pipeline)) - void cmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) const noexcept { - fp_vkCmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress); + void cmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + VkDeviceAddress indirectDeviceAddress) const noexcept + { + fp_vkCmdTraceRaysIndirectKHR(commandBuffer, + pRaygenShaderBindingTable, + pMissShaderBindingTable, + pHitShaderBindingTable, + pCallableShaderBindingTable, + indirectDeviceAddress); } #endif #if (defined(VK_KHR_ray_tracing_maintenance1)) - void cmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) const noexcept { + void cmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) const noexcept + { fp_vkCmdTraceRaysIndirect2KHR(commandBuffer, indirectDeviceAddress); } #endif #if (defined(VK_KHR_acceleration_structure)) - void getDeviceAccelerationStructureCompatibilityKHR(const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) const noexcept { + void getDeviceAccelerationStructureCompatibilityKHR( + const VkAccelerationStructureVersionInfoKHR* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility) const noexcept + { fp_vkGetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility); } #endif #if (defined(VK_KHR_ray_tracing_pipeline)) - VkDeviceSize getRayTracingShaderGroupStackSizeKHR(VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) const noexcept { + VkDeviceSize getRayTracingShaderGroupStackSizeKHR(VkPipeline pipeline, + uint32_t group, + VkShaderGroupShaderKHR groupShader) const noexcept + { return fp_vkGetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader); } #endif #if (defined(VK_KHR_ray_tracing_pipeline)) - void cmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) const noexcept { + void cmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) const noexcept + { fp_vkCmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize); } #endif #if (defined(VK_EXT_full_screen_exclusive)) - VkResult getDeviceGroupSurfacePresentModes2EXT(const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkDeviceGroupPresentModeFlagsKHR* pModes) const noexcept { + VkResult getDeviceGroupSurfacePresentModes2EXT(const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkDeviceGroupPresentModeFlagsKHR* pModes) const noexcept + { return fp_vkGetDeviceGroupSurfacePresentModes2EXT(device, pSurfaceInfo, pModes); } #endif #if (defined(VK_EXT_full_screen_exclusive)) - VkResult acquireFullScreenExclusiveModeEXT(VkSwapchainKHR swapchain) const noexcept { + VkResult acquireFullScreenExclusiveModeEXT(VkSwapchainKHR swapchain) const noexcept + { return fp_vkAcquireFullScreenExclusiveModeEXT(device, swapchain); } #endif #if (defined(VK_EXT_full_screen_exclusive)) - VkResult releaseFullScreenExclusiveModeEXT(VkSwapchainKHR swapchain) const noexcept { + VkResult releaseFullScreenExclusiveModeEXT(VkSwapchainKHR swapchain) const noexcept + { return fp_vkReleaseFullScreenExclusiveModeEXT(device, swapchain); } #endif #if (defined(VK_KHR_performance_query)) - VkResult acquireProfilingLockKHR(const VkAcquireProfilingLockInfoKHR* pInfo) const noexcept { + VkResult acquireProfilingLockKHR(const VkAcquireProfilingLockInfoKHR* pInfo) const noexcept + { return fp_vkAcquireProfilingLockKHR(device, pInfo); } #endif #if (defined(VK_KHR_performance_query)) - void releaseProfilingLockKHR() const noexcept { - fp_vkReleaseProfilingLockKHR(device); - } + void releaseProfilingLockKHR() const noexcept { fp_vkReleaseProfilingLockKHR(device); } #endif #if (defined(VK_EXT_image_drm_format_modifier)) - VkResult getImageDrmFormatModifierPropertiesEXT(VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) const noexcept { + VkResult getImageDrmFormatModifierPropertiesEXT(VkImage image, + VkImageDrmFormatModifierPropertiesEXT* pProperties) const noexcept + { return fp_vkGetImageDrmFormatModifierPropertiesEXT(device, image, pProperties); } #endif #if (defined(VK_VERSION_1_2)) - uint64_t getBufferOpaqueCaptureAddress(const VkBufferDeviceAddressInfoEXT* pInfo) const noexcept { + uint64_t getBufferOpaqueCaptureAddress(const VkBufferDeviceAddressInfoEXT* pInfo) const noexcept + { return fp_vkGetBufferOpaqueCaptureAddress(device, pInfo); } #endif #if (defined(VK_VERSION_1_2)) - VkDeviceAddress getBufferDeviceAddress(const VkBufferDeviceAddressInfoEXT* pInfo) const noexcept { + VkDeviceAddress getBufferDeviceAddress(const VkBufferDeviceAddressInfoEXT* pInfo) const noexcept + { return fp_vkGetBufferDeviceAddress(device, pInfo); } #endif #if (defined(VK_INTEL_performance_query)) - VkResult initializePerformanceApiINTEL(const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) const noexcept { + VkResult initializePerformanceApiINTEL(const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) const noexcept + { return fp_vkInitializePerformanceApiINTEL(device, pInitializeInfo); } #endif #if (defined(VK_INTEL_performance_query)) - void uninitializePerformanceApiINTEL() const noexcept { - fp_vkUninitializePerformanceApiINTEL(device); - } + void uninitializePerformanceApiINTEL() const noexcept { fp_vkUninitializePerformanceApiINTEL(device); } #endif #if (defined(VK_INTEL_performance_query)) - VkResult cmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) const noexcept { + VkResult cmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, + const VkPerformanceMarkerInfoINTEL* pMarkerInfo) const noexcept + { return fp_vkCmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo); } #endif #if (defined(VK_INTEL_performance_query)) - VkResult cmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) const noexcept { + VkResult cmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, + const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) const noexcept + { return fp_vkCmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo); } #endif #if (defined(VK_INTEL_performance_query)) - VkResult cmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) const noexcept { + VkResult cmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, + const VkPerformanceOverrideInfoINTEL* pOverrideInfo) const noexcept + { return fp_vkCmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo); } #endif #if (defined(VK_INTEL_performance_query)) - VkResult acquirePerformanceConfigurationINTEL(const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) const noexcept { + VkResult acquirePerformanceConfigurationINTEL(const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, + VkPerformanceConfigurationINTEL* pConfiguration) const noexcept + { return fp_vkAcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration); } #endif #if (defined(VK_INTEL_performance_query)) - VkResult releasePerformanceConfigurationINTEL(VkPerformanceConfigurationINTEL configuration) const noexcept { + VkResult releasePerformanceConfigurationINTEL(VkPerformanceConfigurationINTEL configuration) const noexcept + { return fp_vkReleasePerformanceConfigurationINTEL(device, configuration); } #endif #if (defined(VK_INTEL_performance_query)) - VkResult queueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) const noexcept { + VkResult queueSetPerformanceConfigurationINTEL(VkQueue queue, + VkPerformanceConfigurationINTEL configuration) const noexcept + { return fp_vkQueueSetPerformanceConfigurationINTEL(queue, configuration); } #endif #if (defined(VK_INTEL_performance_query)) - VkResult getPerformanceParameterINTEL(VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) const noexcept { + VkResult getPerformanceParameterINTEL(VkPerformanceParameterTypeINTEL parameter, + VkPerformanceValueINTEL* pValue) const noexcept + { return fp_vkGetPerformanceParameterINTEL(device, parameter, pValue); } #endif #if (defined(VK_VERSION_1_2)) - uint64_t getDeviceMemoryOpaqueCaptureAddress(const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo) const noexcept { + uint64_t getDeviceMemoryOpaqueCaptureAddress(const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo) const noexcept + { return fp_vkGetDeviceMemoryOpaqueCaptureAddress(device, pInfo); } #endif #if (defined(VK_KHR_pipeline_executable_properties)) - VkResult getPipelineExecutablePropertiesKHR(const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) const noexcept { + VkResult getPipelineExecutablePropertiesKHR(const VkPipelineInfoKHR* pPipelineInfo, + uint32_t* pExecutableCount, + VkPipelineExecutablePropertiesKHR* pProperties) const noexcept + { return fp_vkGetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties); } #endif #if (defined(VK_KHR_pipeline_executable_properties)) - VkResult getPipelineExecutableStatisticsKHR(const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) const noexcept { + VkResult getPipelineExecutableStatisticsKHR(const VkPipelineExecutableInfoKHR* pExecutableInfo, + uint32_t* pStatisticCount, + VkPipelineExecutableStatisticKHR* pStatistics) const noexcept + { return fp_vkGetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics); } #endif #if (defined(VK_KHR_pipeline_executable_properties)) - VkResult getPipelineExecutableInternalRepresentationsKHR(const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) const noexcept { - return fp_vkGetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); + VkResult getPipelineExecutableInternalRepresentationsKHR( + const VkPipelineExecutableInfoKHR* pExecutableInfo, + uint32_t* pInternalRepresentationCount, + VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) const noexcept + { + return fp_vkGetPipelineExecutableInternalRepresentationsKHR( + device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); } #endif #if (defined(VK_KHR_line_rasterization)) - void cmdSetLineStippleKHR(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) const noexcept { + void cmdSetLineStippleKHR(VkCommandBuffer commandBuffer, + uint32_t lineStippleFactor, + uint16_t lineStipplePattern) const noexcept + { fp_vkCmdSetLineStippleKHR(commandBuffer, lineStippleFactor, lineStipplePattern); } #endif #if (defined(VKSC_VERSION_1_0)) - VkResult getFaultData(VkFaultQueryBehavior faultQueryBehavior, VkBool32* pUnrecordedFaults, uint32_t* pFaultCount, VkFaultData* pFaults) const noexcept { + VkResult getFaultData(VkFaultQueryBehavior faultQueryBehavior, + VkBool32* pUnrecordedFaults, + uint32_t* pFaultCount, + VkFaultData* pFaults) const noexcept + { return fp_vkGetFaultData(device, faultQueryBehavior, pUnrecordedFaults, pFaultCount, pFaults); } #endif #if (defined(VK_KHR_acceleration_structure)) - VkResult createAccelerationStructureKHR(const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) const noexcept { + VkResult createAccelerationStructureKHR(const VkAccelerationStructureCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureKHR* pAccelerationStructure) const noexcept + { return fp_vkCreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure); } #endif #if (defined(VK_KHR_acceleration_structure)) - void cmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) const noexcept { + void cmdBuildAccelerationStructuresKHR( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) const noexcept + { fp_vkCmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos); } #endif #if (defined(VK_KHR_acceleration_structure)) - void cmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts) const noexcept { - fp_vkCmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); + void cmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkDeviceAddress* pIndirectDeviceAddresses, + const uint32_t* pIndirectStrides, + const uint32_t* const* ppMaxPrimitiveCounts) const noexcept + { + fp_vkCmdBuildAccelerationStructuresIndirectKHR( + commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); } #endif #if (defined(VK_KHR_acceleration_structure)) - VkResult buildAccelerationStructuresKHR(VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) const noexcept { + VkResult buildAccelerationStructuresKHR( + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) const noexcept + { return fp_vkBuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos); } #endif #if (defined(VK_KHR_acceleration_structure)) - VkDeviceAddress getAccelerationStructureDeviceAddressKHR(const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) const noexcept { + VkDeviceAddress + getAccelerationStructureDeviceAddressKHR(const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) const noexcept + { return fp_vkGetAccelerationStructureDeviceAddressKHR(device, pInfo); } #endif #if (defined(VK_KHR_deferred_host_operations)) - VkResult createDeferredOperationKHR(const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation) const noexcept { + VkResult createDeferredOperationKHR(const VkAllocationCallbacks* pAllocator, + VkDeferredOperationKHR* pDeferredOperation) const noexcept + { return fp_vkCreateDeferredOperationKHR(device, pAllocator, pDeferredOperation); } #endif #if (defined(VK_KHR_deferred_host_operations)) - void destroyDeferredOperationKHR(VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyDeferredOperationKHR(VkDeferredOperationKHR operation, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyDeferredOperationKHR(device, operation, pAllocator); } #endif #if (defined(VK_KHR_deferred_host_operations)) - uint32_t getDeferredOperationMaxConcurrencyKHR(VkDeferredOperationKHR operation) const noexcept { + uint32_t getDeferredOperationMaxConcurrencyKHR(VkDeferredOperationKHR operation) const noexcept + { return fp_vkGetDeferredOperationMaxConcurrencyKHR(device, operation); } #endif #if (defined(VK_KHR_deferred_host_operations)) - VkResult getDeferredOperationResultKHR(VkDeferredOperationKHR operation) const noexcept { + VkResult getDeferredOperationResultKHR(VkDeferredOperationKHR operation) const noexcept + { return fp_vkGetDeferredOperationResultKHR(device, operation); } #endif #if (defined(VK_KHR_deferred_host_operations)) - VkResult deferredOperationJoinKHR(VkDeferredOperationKHR operation) const noexcept { + VkResult deferredOperationJoinKHR(VkDeferredOperationKHR operation) const noexcept + { return fp_vkDeferredOperationJoinKHR(device, operation); } #endif #if (defined(VK_NV_device_generated_commands_compute)) - void getPipelineIndirectMemoryRequirementsNV(const VkComputePipelineCreateInfo* pCreateInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept { + void getPipelineIndirectMemoryRequirementsNV(const VkComputePipelineCreateInfo* pCreateInfo, + VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept + { fp_vkGetPipelineIndirectMemoryRequirementsNV(device, pCreateInfo, pMemoryRequirements); } #endif #if (defined(VK_NV_device_generated_commands_compute)) - VkDeviceAddress getPipelineIndirectDeviceAddressNV(const VkPipelineIndirectDeviceAddressInfoNV* pInfo) const noexcept { + VkDeviceAddress + getPipelineIndirectDeviceAddressNV(const VkPipelineIndirectDeviceAddressInfoNV* pInfo) const noexcept + { return fp_vkGetPipelineIndirectDeviceAddressNV(device, pInfo); } #endif #if (defined(VK_AMD_anti_lag)) - void antiLagUpdateAMD(const VkAntiLagDataAMD* pData) const noexcept { - fp_vkAntiLagUpdateAMD(device, pData); - } + void antiLagUpdateAMD(const VkAntiLagDataAMD* pData) const noexcept { fp_vkAntiLagUpdateAMD(device, pData); } #endif #if (defined(VK_VERSION_1_3)) - void cmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const noexcept { + void cmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const noexcept + { fp_vkCmdSetCullMode(commandBuffer, cullMode); } #endif #if (defined(VK_VERSION_1_3)) - void cmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) const noexcept { + void cmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) const noexcept + { fp_vkCmdSetFrontFace(commandBuffer, frontFace); } #endif #if (defined(VK_VERSION_1_3)) - void cmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const noexcept { + void cmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const noexcept + { fp_vkCmdSetPrimitiveTopology(commandBuffer, primitiveTopology); } #endif #if (defined(VK_VERSION_1_3)) - void cmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) const noexcept { + void cmdSetViewportWithCount(VkCommandBuffer commandBuffer, + uint32_t viewportCount, + const VkViewport* pViewports) const noexcept + { fp_vkCmdSetViewportWithCount(commandBuffer, viewportCount, pViewports); } #endif #if (defined(VK_VERSION_1_3)) - void cmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) const noexcept { + void cmdSetScissorWithCount(VkCommandBuffer commandBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors) const noexcept + { fp_vkCmdSetScissorWithCount(commandBuffer, scissorCount, pScissors); } #endif #if (defined(VK_KHR_maintenance5)) - void cmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkDeviceSize size, VkIndexType indexType) const noexcept { + void cmdBindIndexBuffer2KHR(VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkDeviceSize size, + VkIndexType indexType) const noexcept + { fp_vkCmdBindIndexBuffer2KHR(commandBuffer, buffer, offset, size, indexType); } #endif #if (defined(VK_VERSION_1_3)) - void cmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) const noexcept { + void cmdBindVertexBuffers2(VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides) const noexcept + { fp_vkCmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); } #endif #if (defined(VK_VERSION_1_3)) - void cmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const noexcept { + void cmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const noexcept + { fp_vkCmdSetDepthTestEnable(commandBuffer, depthTestEnable); } #endif #if (defined(VK_VERSION_1_3)) - void cmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const noexcept { + void cmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const noexcept + { fp_vkCmdSetDepthWriteEnable(commandBuffer, depthWriteEnable); } #endif #if (defined(VK_VERSION_1_3)) - void cmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const noexcept { + void cmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const noexcept + { fp_vkCmdSetDepthCompareOp(commandBuffer, depthCompareOp); } #endif #if (defined(VK_VERSION_1_3)) - void cmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const noexcept { + void cmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const noexcept + { fp_vkCmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable); } #endif #if (defined(VK_VERSION_1_3)) - void cmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const noexcept { + void cmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const noexcept + { fp_vkCmdSetStencilTestEnable(commandBuffer, stencilTestEnable); } #endif #if (defined(VK_VERSION_1_3)) - void cmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) const noexcept { + void cmdSetStencilOp(VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp) const noexcept + { fp_vkCmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); } #endif #if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) - void cmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) const noexcept { + void cmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) const noexcept + { fp_vkCmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints); } #endif #if (defined(VK_VERSION_1_3)) - void cmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const noexcept { + void cmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const noexcept + { fp_vkCmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable); } #endif #if (defined(VK_VERSION_1_3)) - void cmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const noexcept { + void cmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const noexcept + { fp_vkCmdSetDepthBiasEnable(commandBuffer, depthBiasEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) - void cmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) const noexcept { + void cmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) const noexcept + { fp_vkCmdSetLogicOpEXT(commandBuffer, logicOp); } #endif #if (defined(VK_VERSION_1_3)) - void cmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const noexcept { + void cmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const noexcept + { fp_vkCmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, VkTessellationDomainOriginKHR domainOrigin) const noexcept { + void cmdSetTessellationDomainOriginEXT(VkCommandBuffer commandBuffer, + VkTessellationDomainOriginKHR domainOrigin) const noexcept + { fp_vkCmdSetTessellationDomainOriginEXT(commandBuffer, domainOrigin); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) const noexcept { + void cmdSetDepthClampEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClampEnable) const noexcept + { fp_vkCmdSetDepthClampEnableEXT(commandBuffer, depthClampEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) const noexcept { + void cmdSetPolygonModeEXT(VkCommandBuffer commandBuffer, VkPolygonMode polygonMode) const noexcept + { fp_vkCmdSetPolygonModeEXT(commandBuffer, polygonMode); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits rasterizationSamples) const noexcept { + void cmdSetRasterizationSamplesEXT(VkCommandBuffer commandBuffer, + VkSampleCountFlagBits rasterizationSamples) const noexcept + { fp_vkCmdSetRasterizationSamplesEXT(commandBuffer, rasterizationSamples); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, VkSampleCountFlagBits samples, const VkSampleMask* pSampleMask) const noexcept { + void cmdSetSampleMaskEXT(VkCommandBuffer commandBuffer, + VkSampleCountFlagBits samples, + const VkSampleMask* pSampleMask) const noexcept + { fp_vkCmdSetSampleMaskEXT(commandBuffer, samples, pSampleMask); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) const noexcept { + void cmdSetAlphaToCoverageEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToCoverageEnable) const noexcept + { fp_vkCmdSetAlphaToCoverageEnableEXT(commandBuffer, alphaToCoverageEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) const noexcept { + void cmdSetAlphaToOneEnableEXT(VkCommandBuffer commandBuffer, VkBool32 alphaToOneEnable) const noexcept + { fp_vkCmdSetAlphaToOneEnableEXT(commandBuffer, alphaToOneEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) const noexcept { + void cmdSetLogicOpEnableEXT(VkCommandBuffer commandBuffer, VkBool32 logicOpEnable) const noexcept + { fp_vkCmdSetLogicOpEnableEXT(commandBuffer, logicOpEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkBool32* pColorBlendEnables) const noexcept { + void cmdSetColorBlendEnableEXT(VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkBool32* pColorBlendEnables) const noexcept + { fp_vkCmdSetColorBlendEnableEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEnables); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendEquationEXT* pColorBlendEquations) const noexcept { + void cmdSetColorBlendEquationEXT(VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendEquationEXT* pColorBlendEquations) const noexcept + { fp_vkCmdSetColorBlendEquationEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendEquations); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorComponentFlags* pColorWriteMasks) const noexcept { + void cmdSetColorWriteMaskEXT(VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorComponentFlags* pColorWriteMasks) const noexcept + { fp_vkCmdSetColorWriteMaskEXT(commandBuffer, firstAttachment, attachmentCount, pColorWriteMasks); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream) const noexcept { + void cmdSetRasterizationStreamEXT(VkCommandBuffer commandBuffer, uint32_t rasterizationStream) const noexcept + { fp_vkCmdSetRasterizationStreamEXT(commandBuffer, rasterizationStream); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetConservativeRasterizationModeEXT(VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) const noexcept { + void cmdSetConservativeRasterizationModeEXT( + VkCommandBuffer commandBuffer, VkConservativeRasterizationModeEXT conservativeRasterizationMode) const noexcept + { fp_vkCmdSetConservativeRasterizationModeEXT(commandBuffer, conservativeRasterizationMode); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, float extraPrimitiveOverestimationSize) const noexcept { + void cmdSetExtraPrimitiveOverestimationSizeEXT(VkCommandBuffer commandBuffer, + float extraPrimitiveOverestimationSize) const noexcept + { fp_vkCmdSetExtraPrimitiveOverestimationSizeEXT(commandBuffer, extraPrimitiveOverestimationSize); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) const noexcept { + void cmdSetDepthClipEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthClipEnable) const noexcept + { fp_vkCmdSetDepthClipEnableEXT(commandBuffer, depthClipEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) const noexcept { + void cmdSetSampleLocationsEnableEXT(VkCommandBuffer commandBuffer, VkBool32 sampleLocationsEnable) const noexcept + { fp_vkCmdSetSampleLocationsEnableEXT(commandBuffer, sampleLocationsEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, uint32_t firstAttachment, uint32_t attachmentCount, const VkColorBlendAdvancedEXT* pColorBlendAdvanced) const noexcept { + void cmdSetColorBlendAdvancedEXT(VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendAdvancedEXT* pColorBlendAdvanced) const noexcept + { fp_vkCmdSetColorBlendAdvancedEXT(commandBuffer, firstAttachment, attachmentCount, pColorBlendAdvanced); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, VkProvokingVertexModeEXT provokingVertexMode) const noexcept { + void cmdSetProvokingVertexModeEXT(VkCommandBuffer commandBuffer, + VkProvokingVertexModeEXT provokingVertexMode) const noexcept + { fp_vkCmdSetProvokingVertexModeEXT(commandBuffer, provokingVertexMode); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, VkLineRasterizationModeEXT lineRasterizationMode) const noexcept { + void cmdSetLineRasterizationModeEXT(VkCommandBuffer commandBuffer, + VkLineRasterizationModeEXT lineRasterizationMode) const noexcept + { fp_vkCmdSetLineRasterizationModeEXT(commandBuffer, lineRasterizationMode); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) const noexcept { + void cmdSetLineStippleEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stippledLineEnable) const noexcept + { fp_vkCmdSetLineStippleEnableEXT(commandBuffer, stippledLineEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) const noexcept { + void cmdSetDepthClipNegativeOneToOneEXT(VkCommandBuffer commandBuffer, VkBool32 negativeOneToOne) const noexcept + { fp_vkCmdSetDepthClipNegativeOneToOneEXT(commandBuffer, negativeOneToOne); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) const noexcept { + void cmdSetViewportWScalingEnableNV(VkCommandBuffer commandBuffer, VkBool32 viewportWScalingEnable) const noexcept + { fp_vkCmdSetViewportWScalingEnableNV(commandBuffer, viewportWScalingEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportSwizzleNV* pViewportSwizzles) const noexcept { + void cmdSetViewportSwizzleNV(VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportSwizzleNV* pViewportSwizzles) const noexcept + { fp_vkCmdSetViewportSwizzleNV(commandBuffer, firstViewport, viewportCount, pViewportSwizzles); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) const noexcept { + void cmdSetCoverageToColorEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageToColorEnable) const noexcept + { fp_vkCmdSetCoverageToColorEnableNV(commandBuffer, coverageToColorEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) const noexcept { + void cmdSetCoverageToColorLocationNV(VkCommandBuffer commandBuffer, uint32_t coverageToColorLocation) const noexcept + { fp_vkCmdSetCoverageToColorLocationNV(commandBuffer, coverageToColorLocation); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, VkCoverageModulationModeNV coverageModulationMode) const noexcept { + void cmdSetCoverageModulationModeNV(VkCommandBuffer commandBuffer, + VkCoverageModulationModeNV coverageModulationMode) const noexcept + { fp_vkCmdSetCoverageModulationModeNV(commandBuffer, coverageModulationMode); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, VkBool32 coverageModulationTableEnable) const noexcept { + void cmdSetCoverageModulationTableEnableNV(VkCommandBuffer commandBuffer, + VkBool32 coverageModulationTableEnable) const noexcept + { fp_vkCmdSetCoverageModulationTableEnableNV(commandBuffer, coverageModulationTableEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, uint32_t coverageModulationTableCount, const float* pCoverageModulationTable) const noexcept { + void cmdSetCoverageModulationTableNV(VkCommandBuffer commandBuffer, + uint32_t coverageModulationTableCount, + const float* pCoverageModulationTable) const noexcept + { fp_vkCmdSetCoverageModulationTableNV(commandBuffer, coverageModulationTableCount, pCoverageModulationTable); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) const noexcept { + void cmdSetShadingRateImageEnableNV(VkCommandBuffer commandBuffer, VkBool32 shadingRateImageEnable) const noexcept + { fp_vkCmdSetShadingRateImageEnableNV(commandBuffer, shadingRateImageEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, VkCoverageReductionModeNV coverageReductionMode) const noexcept { + void cmdSetCoverageReductionModeNV(VkCommandBuffer commandBuffer, + VkCoverageReductionModeNV coverageReductionMode) const noexcept + { fp_vkCmdSetCoverageReductionModeNV(commandBuffer, coverageReductionMode); } #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) - void cmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, VkBool32 representativeFragmentTestEnable) const noexcept { + void cmdSetRepresentativeFragmentTestEnableNV(VkCommandBuffer commandBuffer, + VkBool32 representativeFragmentTestEnable) const noexcept + { fp_vkCmdSetRepresentativeFragmentTestEnableNV(commandBuffer, representativeFragmentTestEnable); } #endif #if (defined(VK_VERSION_1_3)) - VkResult createPrivateDataSlot(const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlotEXT* pPrivateDataSlot) const noexcept { + VkResult createPrivateDataSlot(const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlotEXT* pPrivateDataSlot) const noexcept + { return fp_vkCreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot); } #endif #if (defined(VK_VERSION_1_3)) - void destroyPrivateDataSlot(VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyPrivateDataSlot(VkPrivateDataSlotEXT privateDataSlot, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyPrivateDataSlot(device, privateDataSlot, pAllocator); } #endif #if (defined(VK_VERSION_1_3)) - VkResult setPrivateData(VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data) const noexcept { + VkResult setPrivateData(VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlotEXT privateDataSlot, + uint64_t data) const noexcept + { return fp_vkSetPrivateData(device, objectType, objectHandle, privateDataSlot, data); } #endif #if (defined(VK_VERSION_1_3)) - void getPrivateData(VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t* pData) const noexcept { + void getPrivateData(VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlotEXT privateDataSlot, + uint64_t* pData) const noexcept + { fp_vkGetPrivateData(device, objectType, objectHandle, privateDataSlot, pData); } #endif #if (defined(VK_VERSION_1_3)) - void cmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR* pCopyBufferInfo) const noexcept { + void cmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR* pCopyBufferInfo) const noexcept + { fp_vkCmdCopyBuffer2(commandBuffer, pCopyBufferInfo); } #endif #if (defined(VK_VERSION_1_3)) - void cmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR* pCopyImageInfo) const noexcept { + void cmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR* pCopyImageInfo) const noexcept + { fp_vkCmdCopyImage2(commandBuffer, pCopyImageInfo); } #endif #if (defined(VK_VERSION_1_3)) - void cmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR* pBlitImageInfo) const noexcept { + void cmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR* pBlitImageInfo) const noexcept + { fp_vkCmdBlitImage2(commandBuffer, pBlitImageInfo); } #endif #if (defined(VK_VERSION_1_3)) - void cmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo) const noexcept { + void cmdCopyBufferToImage2(VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo) const noexcept + { fp_vkCmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo); } #endif #if (defined(VK_VERSION_1_3)) - void cmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo) const noexcept { + void cmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo) const noexcept + { fp_vkCmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo); } #endif #if (defined(VK_VERSION_1_3)) - void cmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR* pResolveImageInfo) const noexcept { + void cmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR* pResolveImageInfo) const noexcept + { fp_vkCmdResolveImage2(commandBuffer, pResolveImageInfo); } #endif #if (defined(VK_KHR_object_refresh)) - void cmdRefreshObjectsKHR(VkCommandBuffer commandBuffer, const VkRefreshObjectListKHR* pRefreshObjects) const noexcept { + void cmdRefreshObjectsKHR(VkCommandBuffer commandBuffer, + const VkRefreshObjectListKHR* pRefreshObjects) const noexcept + { fp_vkCmdRefreshObjectsKHR(commandBuffer, pRefreshObjects); } #endif #if (defined(VK_KHR_fragment_shading_rate)) - void cmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const noexcept { + void cmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, + const VkExtent2D* pFragmentSize, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const noexcept + { fp_vkCmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps); } #endif #if (defined(VK_NV_fragment_shading_rate_enums)) - void cmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const noexcept { + void cmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, + VkFragmentShadingRateNV shadingRate, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) const noexcept + { fp_vkCmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps); } #endif #if (defined(VK_KHR_acceleration_structure)) - void getAccelerationStructureBuildSizesKHR(VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) const noexcept { + void getAccelerationStructureBuildSizesKHR(VkAccelerationStructureBuildTypeKHR buildType, + const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, + const uint32_t* pMaxPrimitiveCounts, + VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) const noexcept + { fp_vkGetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo); } #endif #if (defined(VK_EXT_vertex_input_dynamic_state)) || (defined(VK_EXT_shader_object)) - void cmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) const noexcept { - fp_vkCmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); + void cmdSetVertexInputEXT(VkCommandBuffer commandBuffer, + uint32_t vertexBindingDescriptionCount, + const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) const noexcept + { + fp_vkCmdSetVertexInputEXT(commandBuffer, + vertexBindingDescriptionCount, + pVertexBindingDescriptions, + vertexAttributeDescriptionCount, + pVertexAttributeDescriptions); } #endif #if (defined(VK_EXT_color_write_enable)) - void cmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) const noexcept { + void cmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkBool32* pColorWriteEnables) const noexcept + { fp_vkCmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables); } #endif #if (defined(VK_VERSION_1_3)) - void cmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR* pDependencyInfo) const noexcept { + void cmdSetEvent2(VkCommandBuffer commandBuffer, + VkEvent event, + const VkDependencyInfoKHR* pDependencyInfo) const noexcept + { fp_vkCmdSetEvent2(commandBuffer, event, pDependencyInfo); } #endif #if (defined(VK_VERSION_1_3)) - void cmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask) const noexcept { + void cmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask) const noexcept + { fp_vkCmdResetEvent2(commandBuffer, event, stageMask); } #endif #if (defined(VK_VERSION_1_3)) - void cmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfoKHR* pDependencyInfos) const noexcept { + void cmdWaitEvents2(VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + const VkDependencyInfoKHR* pDependencyInfos) const noexcept + { fp_vkCmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos); } #endif #if (defined(VK_VERSION_1_3)) - void cmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR* pDependencyInfo) const noexcept { + void cmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR* pDependencyInfo) const noexcept + { fp_vkCmdPipelineBarrier2(commandBuffer, pDependencyInfo); } #endif #if (defined(VK_VERSION_1_3)) - VkResult queueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR* pSubmits, VkFence fence) const noexcept { + VkResult + queueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR* pSubmits, VkFence fence) const noexcept + { return fp_vkQueueSubmit2(queue, submitCount, pSubmits, fence); } #endif #if (defined(VK_VERSION_1_3)) - void cmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query) const noexcept { + void cmdWriteTimestamp2(VkCommandBuffer commandBuffer, + VkPipelineStageFlags2KHR stage, + VkQueryPool queryPool, + uint32_t query) const noexcept + { fp_vkCmdWriteTimestamp2(commandBuffer, stage, queryPool, query); } #endif #if (defined(VK_KHR_synchronization2)) - void cmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) const noexcept { + void cmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, + VkPipelineStageFlags2KHR stage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker) const noexcept + { fp_vkCmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker); } #endif #if (defined(VK_KHR_synchronization2)) - void getQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) const noexcept { + void getQueueCheckpointData2NV(VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointData2NV* pCheckpointData) const noexcept + { fp_vkGetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData); } #endif #if (defined(VK_EXT_host_image_copy)) - VkResult copyMemoryToImageEXT(const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) const noexcept { + VkResult copyMemoryToImageEXT(const VkCopyMemoryToImageInfoEXT* pCopyMemoryToImageInfo) const noexcept + { return fp_vkCopyMemoryToImageEXT(device, pCopyMemoryToImageInfo); } #endif #if (defined(VK_EXT_host_image_copy)) - VkResult copyImageToMemoryEXT(const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) const noexcept { + VkResult copyImageToMemoryEXT(const VkCopyImageToMemoryInfoEXT* pCopyImageToMemoryInfo) const noexcept + { return fp_vkCopyImageToMemoryEXT(device, pCopyImageToMemoryInfo); } #endif #if (defined(VK_EXT_host_image_copy)) - VkResult copyImageToImageEXT(const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) const noexcept { + VkResult copyImageToImageEXT(const VkCopyImageToImageInfoEXT* pCopyImageToImageInfo) const noexcept + { return fp_vkCopyImageToImageEXT(device, pCopyImageToImageInfo); } #endif #if (defined(VK_EXT_host_image_copy)) - VkResult transitionImageLayoutEXT(uint32_t transitionCount, const VkHostImageLayoutTransitionInfoEXT* pTransitions) const noexcept { + VkResult transitionImageLayoutEXT(uint32_t transitionCount, + const VkHostImageLayoutTransitionInfoEXT* pTransitions) const noexcept + { return fp_vkTransitionImageLayoutEXT(device, transitionCount, pTransitions); } #endif #if (defined(VKSC_VERSION_1_0)) - void getCommandPoolMemoryConsumption(VkCommandPool commandPool, VkCommandBuffer commandBuffer, VkCommandPoolMemoryConsumption* pConsumption) const noexcept { + void getCommandPoolMemoryConsumption(VkCommandPool commandPool, + VkCommandBuffer commandBuffer, + VkCommandPoolMemoryConsumption* pConsumption) const noexcept + { fp_vkGetCommandPoolMemoryConsumption(device, commandPool, commandBuffer, pConsumption); } #endif #if (defined(VK_KHR_video_queue)) - VkResult createVideoSessionKHR(const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) const noexcept { + VkResult createVideoSessionKHR(const VkVideoSessionCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionKHR* pVideoSession) const noexcept + { return fp_vkCreateVideoSessionKHR(device, pCreateInfo, pAllocator, pVideoSession); } #endif #if (defined(VK_KHR_video_queue)) - void destroyVideoSessionKHR(VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyVideoSessionKHR(VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyVideoSessionKHR(device, videoSession, pAllocator); } #endif #if (defined(VK_KHR_video_queue)) - VkResult createVideoSessionParametersKHR(const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) const noexcept { + VkResult createVideoSessionParametersKHR(const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionParametersKHR* pVideoSessionParameters) const noexcept + { return fp_vkCreateVideoSessionParametersKHR(device, pCreateInfo, pAllocator, pVideoSessionParameters); } #endif #if (defined(VK_KHR_video_queue)) - VkResult updateVideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) const noexcept { + VkResult updateVideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParameters, + const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) const noexcept + { return fp_vkUpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo); } #endif #if (defined(VK_KHR_video_encode_queue)) - VkResult getEncodedVideoSessionParametersKHR(const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, size_t* pDataSize, void* pData) const noexcept { - return fp_vkGetEncodedVideoSessionParametersKHR(device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData); + VkResult + getEncodedVideoSessionParametersKHR(const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, + VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, + size_t* pDataSize, + void* pData) const noexcept + { + return fp_vkGetEncodedVideoSessionParametersKHR( + device, pVideoSessionParametersInfo, pFeedbackInfo, pDataSize, pData); } #endif #if (defined(VK_KHR_video_queue)) - void destroyVideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyVideoSessionParametersKHR(VkVideoSessionParametersKHR videoSessionParameters, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator); } #endif #if (defined(VK_KHR_video_queue)) - VkResult getVideoSessionMemoryRequirementsKHR(VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) const noexcept { - return fp_vkGetVideoSessionMemoryRequirementsKHR(device, videoSession, pMemoryRequirementsCount, pMemoryRequirements); + VkResult + getVideoSessionMemoryRequirementsKHR(VkVideoSessionKHR videoSession, + uint32_t* pMemoryRequirementsCount, + VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) const noexcept + { + return fp_vkGetVideoSessionMemoryRequirementsKHR( + device, videoSession, pMemoryRequirementsCount, pMemoryRequirements); } #endif #if (defined(VK_KHR_video_queue)) - VkResult bindVideoSessionMemoryKHR(VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) const noexcept { - return fp_vkBindVideoSessionMemoryKHR(device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos); + VkResult bindVideoSessionMemoryKHR(VkVideoSessionKHR videoSession, + uint32_t bindSessionMemoryInfoCount, + const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) const noexcept + { + return fp_vkBindVideoSessionMemoryKHR( + device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos); } #endif #if (defined(VK_KHR_video_decode_queue)) - void cmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo) const noexcept { + void cmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pDecodeInfo) const noexcept + { fp_vkCmdDecodeVideoKHR(commandBuffer, pDecodeInfo); } #endif #if (defined(VK_KHR_video_queue)) - void cmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) const noexcept { + void cmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, + const VkVideoBeginCodingInfoKHR* pBeginInfo) const noexcept + { fp_vkCmdBeginVideoCodingKHR(commandBuffer, pBeginInfo); } #endif #if (defined(VK_KHR_video_queue)) - void cmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) const noexcept { + void cmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, + const VkVideoCodingControlInfoKHR* pCodingControlInfo) const noexcept + { fp_vkCmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo); } #endif #if (defined(VK_KHR_video_queue)) - void cmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) const noexcept { + void cmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, + const VkVideoEndCodingInfoKHR* pEndCodingInfo) const noexcept + { fp_vkCmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo); } #endif #if (defined(VK_KHR_video_encode_queue)) - void cmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) const noexcept { + void cmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) const noexcept + { fp_vkCmdEncodeVideoKHR(commandBuffer, pEncodeInfo); } #endif #if (defined(VK_NV_memory_decompression)) - void cmdDecompressMemoryNV(VkCommandBuffer commandBuffer, uint32_t decompressRegionCount, const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) const noexcept { + void cmdDecompressMemoryNV(VkCommandBuffer commandBuffer, + uint32_t decompressRegionCount, + const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) const noexcept + { fp_vkCmdDecompressMemoryNV(commandBuffer, decompressRegionCount, pDecompressMemoryRegions); } #endif #if (defined(VK_NV_memory_decompression)) - void cmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, VkDeviceAddress indirectCommandsAddress, VkDeviceAddress indirectCommandsCountAddress, uint32_t stride) const noexcept { - fp_vkCmdDecompressMemoryIndirectCountNV(commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride); + void cmdDecompressMemoryIndirectCountNV(VkCommandBuffer commandBuffer, + VkDeviceAddress indirectCommandsAddress, + VkDeviceAddress indirectCommandsCountAddress, + uint32_t stride) const noexcept + { + fp_vkCmdDecompressMemoryIndirectCountNV( + commandBuffer, indirectCommandsAddress, indirectCommandsCountAddress, stride); } #endif #if (defined(VK_EXT_descriptor_buffer)) - void getDescriptorSetLayoutSizeEXT(VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes) const noexcept { + void getDescriptorSetLayoutSizeEXT(VkDescriptorSetLayout layout, VkDeviceSize* pLayoutSizeInBytes) const noexcept + { fp_vkGetDescriptorSetLayoutSizeEXT(device, layout, pLayoutSizeInBytes); } #endif #if (defined(VK_EXT_descriptor_buffer)) - void getDescriptorSetLayoutBindingOffsetEXT(VkDescriptorSetLayout layout, uint32_t binding, VkDeviceSize* pOffset) const noexcept { + void getDescriptorSetLayoutBindingOffsetEXT(VkDescriptorSetLayout layout, + uint32_t binding, + VkDeviceSize* pOffset) const noexcept + { fp_vkGetDescriptorSetLayoutBindingOffsetEXT(device, layout, binding, pOffset); } #endif #if (defined(VK_EXT_descriptor_buffer)) - void getDescriptorEXT(const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor) const noexcept { + void + getDescriptorEXT(const VkDescriptorGetInfoEXT* pDescriptorInfo, size_t dataSize, void* pDescriptor) const noexcept + { fp_vkGetDescriptorEXT(device, pDescriptorInfo, dataSize, pDescriptor); } #endif #if (defined(VK_EXT_descriptor_buffer)) - void cmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, uint32_t bufferCount, const VkDescriptorBufferBindingInfoEXT* pBindingInfos) const noexcept { + void cmdBindDescriptorBuffersEXT(VkCommandBuffer commandBuffer, + uint32_t bufferCount, + const VkDescriptorBufferBindingInfoEXT* pBindingInfos) const noexcept + { fp_vkCmdBindDescriptorBuffersEXT(commandBuffer, bufferCount, pBindingInfos); } #endif #if (defined(VK_EXT_descriptor_buffer)) - void cmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const uint32_t* pBufferIndices, const VkDeviceSize* pOffsets) const noexcept { - fp_vkCmdSetDescriptorBufferOffsetsEXT(commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets); + void cmdSetDescriptorBufferOffsetsEXT(VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t setCount, + const uint32_t* pBufferIndices, + const VkDeviceSize* pOffsets) const noexcept + { + fp_vkCmdSetDescriptorBufferOffsetsEXT( + commandBuffer, pipelineBindPoint, layout, firstSet, setCount, pBufferIndices, pOffsets); } #endif #if (defined(VK_EXT_descriptor_buffer)) - void cmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set) const noexcept { + void cmdBindDescriptorBufferEmbeddedSamplersEXT(VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set) const noexcept + { fp_vkCmdBindDescriptorBufferEmbeddedSamplersEXT(commandBuffer, pipelineBindPoint, layout, set); } #endif #if (defined(VK_EXT_descriptor_buffer)) - VkResult getBufferOpaqueCaptureDescriptorDataEXT(const VkBufferCaptureDescriptorDataInfoEXT* pInfo, void* pData) const noexcept { + VkResult getBufferOpaqueCaptureDescriptorDataEXT(const VkBufferCaptureDescriptorDataInfoEXT* pInfo, + void* pData) const noexcept + { return fp_vkGetBufferOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); } #endif #if (defined(VK_EXT_descriptor_buffer)) - VkResult getImageOpaqueCaptureDescriptorDataEXT(const VkImageCaptureDescriptorDataInfoEXT* pInfo, void* pData) const noexcept { + VkResult getImageOpaqueCaptureDescriptorDataEXT(const VkImageCaptureDescriptorDataInfoEXT* pInfo, + void* pData) const noexcept + { return fp_vkGetImageOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); } #endif #if (defined(VK_EXT_descriptor_buffer)) - VkResult getImageViewOpaqueCaptureDescriptorDataEXT(const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, void* pData) const noexcept { + VkResult getImageViewOpaqueCaptureDescriptorDataEXT(const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, + void* pData) const noexcept + { return fp_vkGetImageViewOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); } #endif #if (defined(VK_EXT_descriptor_buffer)) - VkResult getSamplerOpaqueCaptureDescriptorDataEXT(const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, void* pData) const noexcept { + VkResult getSamplerOpaqueCaptureDescriptorDataEXT(const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, + void* pData) const noexcept + { return fp_vkGetSamplerOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); } #endif #if (defined(VK_EXT_descriptor_buffer)) - VkResult getAccelerationStructureOpaqueCaptureDescriptorDataEXT(const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) const noexcept { + VkResult getAccelerationStructureOpaqueCaptureDescriptorDataEXT( + const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, void* pData) const noexcept + { return fp_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT(device, pInfo, pData); } #endif #if (defined(VK_EXT_pageable_device_local_memory)) - void setDeviceMemoryPriorityEXT(VkDeviceMemory memory, float priority) const noexcept { + void setDeviceMemoryPriorityEXT(VkDeviceMemory memory, float priority) const noexcept + { fp_vkSetDeviceMemoryPriorityEXT(device, memory, priority); } #endif #if (defined(VK_KHR_present_wait)) - VkResult waitForPresentKHR(VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) const noexcept { + VkResult waitForPresentKHR(VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) const noexcept + { return fp_vkWaitForPresentKHR(device, swapchain, presentId, timeout); } #endif #if (defined(VK_FUCHSIA_buffer_collection)) - VkResult createBufferCollectionFUCHSIA(const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection) const noexcept { + VkResult createBufferCollectionFUCHSIA(const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferCollectionFUCHSIA* pCollection) const noexcept + { return fp_vkCreateBufferCollectionFUCHSIA(device, pCreateInfo, pAllocator, pCollection); } #endif #if (defined(VK_FUCHSIA_buffer_collection)) - VkResult setBufferCollectionBufferConstraintsFUCHSIA(VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) const noexcept { + VkResult setBufferCollectionBufferConstraintsFUCHSIA( + VkBufferCollectionFUCHSIA collection, + const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) const noexcept + { return fp_vkSetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo); } #endif #if (defined(VK_FUCHSIA_buffer_collection)) - VkResult setBufferCollectionImageConstraintsFUCHSIA(VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) const noexcept { + VkResult setBufferCollectionImageConstraintsFUCHSIA( + VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) const noexcept + { return fp_vkSetBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo); } #endif #if (defined(VK_FUCHSIA_buffer_collection)) - void destroyBufferCollectionFUCHSIA(VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyBufferCollectionFUCHSIA(VkBufferCollectionFUCHSIA collection, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyBufferCollectionFUCHSIA(device, collection, pAllocator); } #endif #if (defined(VK_FUCHSIA_buffer_collection)) - VkResult getBufferCollectionPropertiesFUCHSIA(VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties) const noexcept { + VkResult getBufferCollectionPropertiesFUCHSIA(VkBufferCollectionFUCHSIA collection, + VkBufferCollectionPropertiesFUCHSIA* pProperties) const noexcept + { return fp_vkGetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties); } #endif #if (defined(VK_NV_cuda_kernel_launch)) - VkResult createCudaModuleNV(const VkCudaModuleCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaModuleNV* pModule) const noexcept { + VkResult createCudaModuleNV(const VkCudaModuleCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCudaModuleNV* pModule) const noexcept + { return fp_vkCreateCudaModuleNV(device, pCreateInfo, pAllocator, pModule); } #endif #if (defined(VK_NV_cuda_kernel_launch)) - VkResult getCudaModuleCacheNV(VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData) const noexcept { + VkResult getCudaModuleCacheNV(VkCudaModuleNV module, size_t* pCacheSize, void* pCacheData) const noexcept + { return fp_vkGetCudaModuleCacheNV(device, module, pCacheSize, pCacheData); } #endif #if (defined(VK_NV_cuda_kernel_launch)) - VkResult createCudaFunctionNV(const VkCudaFunctionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCudaFunctionNV* pFunction) const noexcept { + VkResult createCudaFunctionNV(const VkCudaFunctionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCudaFunctionNV* pFunction) const noexcept + { return fp_vkCreateCudaFunctionNV(device, pCreateInfo, pAllocator, pFunction); } #endif #if (defined(VK_NV_cuda_kernel_launch)) - void destroyCudaModuleNV(VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyCudaModuleNV(VkCudaModuleNV module, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyCudaModuleNV(device, module, pAllocator); } #endif #if (defined(VK_NV_cuda_kernel_launch)) - void destroyCudaFunctionNV(VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyCudaFunctionNV(VkCudaFunctionNV function, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyCudaFunctionNV(device, function, pAllocator); } #endif #if (defined(VK_NV_cuda_kernel_launch)) - void cmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo) const noexcept { + void cmdCudaLaunchKernelNV(VkCommandBuffer commandBuffer, const VkCudaLaunchInfoNV* pLaunchInfo) const noexcept + { fp_vkCmdCudaLaunchKernelNV(commandBuffer, pLaunchInfo); } #endif #if (defined(VK_VERSION_1_3)) - void cmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo) const noexcept { + void cmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo) const noexcept + { fp_vkCmdBeginRendering(commandBuffer, pRenderingInfo); } #endif #if (defined(VK_VERSION_1_3)) - void cmdEndRendering(VkCommandBuffer commandBuffer) const noexcept { - fp_vkCmdEndRendering(commandBuffer); - } + void cmdEndRendering(VkCommandBuffer commandBuffer) const noexcept { fp_vkCmdEndRendering(commandBuffer); } #endif #if (defined(VK_VALVE_descriptor_set_host_mapping)) - void getDescriptorSetLayoutHostMappingInfoVALVE(const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) const noexcept { + void + getDescriptorSetLayoutHostMappingInfoVALVE(const VkDescriptorSetBindingReferenceVALVE* pBindingReference, + VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) const noexcept + { fp_vkGetDescriptorSetLayoutHostMappingInfoVALVE(device, pBindingReference, pHostMapping); } #endif #if (defined(VK_VALVE_descriptor_set_host_mapping)) - void getDescriptorSetHostMappingVALVE(VkDescriptorSet descriptorSet, void** ppData) const noexcept { + void getDescriptorSetHostMappingVALVE(VkDescriptorSet descriptorSet, void** ppData) const noexcept + { fp_vkGetDescriptorSetHostMappingVALVE(device, descriptorSet, ppData); } #endif #if (defined(VK_EXT_opacity_micromap)) - VkResult createMicromapEXT(const VkMicromapCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkMicromapEXT* pMicromap) const noexcept { + VkResult createMicromapEXT(const VkMicromapCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkMicromapEXT* pMicromap) const noexcept + { return fp_vkCreateMicromapEXT(device, pCreateInfo, pAllocator, pMicromap); } #endif #if (defined(VK_EXT_opacity_micromap)) - void cmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) const noexcept { + void cmdBuildMicromapsEXT(VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos) const noexcept + { fp_vkCmdBuildMicromapsEXT(commandBuffer, infoCount, pInfos); } #endif #if (defined(VK_EXT_opacity_micromap)) - VkResult buildMicromapsEXT(VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkMicromapBuildInfoEXT* pInfos) const noexcept { + VkResult buildMicromapsEXT(VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos) const noexcept + { return fp_vkBuildMicromapsEXT(device, deferredOperation, infoCount, pInfos); } #endif #if (defined(VK_EXT_opacity_micromap)) - void destroyMicromapEXT(VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyMicromapEXT(VkMicromapEXT micromap, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyMicromapEXT(device, micromap, pAllocator); } #endif #if (defined(VK_EXT_opacity_micromap)) - void cmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) const noexcept { + void cmdCopyMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapInfoEXT* pInfo) const noexcept + { fp_vkCmdCopyMicromapEXT(commandBuffer, pInfo); } #endif #if (defined(VK_EXT_opacity_micromap)) - VkResult copyMicromapEXT(VkDeferredOperationKHR deferredOperation, const VkCopyMicromapInfoEXT* pInfo) const noexcept { + VkResult copyMicromapEXT(VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapInfoEXT* pInfo) const noexcept + { return fp_vkCopyMicromapEXT(device, deferredOperation, pInfo); } #endif #if (defined(VK_EXT_opacity_micromap)) - void cmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, const VkCopyMicromapToMemoryInfoEXT* pInfo) const noexcept { + void cmdCopyMicromapToMemoryEXT(VkCommandBuffer commandBuffer, + const VkCopyMicromapToMemoryInfoEXT* pInfo) const noexcept + { fp_vkCmdCopyMicromapToMemoryEXT(commandBuffer, pInfo); } #endif #if (defined(VK_EXT_opacity_micromap)) - VkResult copyMicromapToMemoryEXT(VkDeferredOperationKHR deferredOperation, const VkCopyMicromapToMemoryInfoEXT* pInfo) const noexcept { + VkResult copyMicromapToMemoryEXT(VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapToMemoryInfoEXT* pInfo) const noexcept + { return fp_vkCopyMicromapToMemoryEXT(device, deferredOperation, pInfo); } #endif #if (defined(VK_EXT_opacity_micromap)) - void cmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, const VkCopyMemoryToMicromapInfoEXT* pInfo) const noexcept { + void cmdCopyMemoryToMicromapEXT(VkCommandBuffer commandBuffer, + const VkCopyMemoryToMicromapInfoEXT* pInfo) const noexcept + { fp_vkCmdCopyMemoryToMicromapEXT(commandBuffer, pInfo); } #endif #if (defined(VK_EXT_opacity_micromap)) - VkResult copyMemoryToMicromapEXT(VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToMicromapInfoEXT* pInfo) const noexcept { + VkResult copyMemoryToMicromapEXT(VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToMicromapInfoEXT* pInfo) const noexcept + { return fp_vkCopyMemoryToMicromapEXT(device, deferredOperation, pInfo); } #endif #if (defined(VK_EXT_opacity_micromap)) - void cmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) const noexcept { + void cmdWriteMicromapsPropertiesEXT(VkCommandBuffer commandBuffer, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery) const noexcept + { fp_vkCmdWriteMicromapsPropertiesEXT(commandBuffer, micromapCount, pMicromaps, queryType, queryPool, firstQuery); } #endif #if (defined(VK_EXT_opacity_micromap)) - VkResult writeMicromapsPropertiesEXT(uint32_t micromapCount, const VkMicromapEXT* pMicromaps, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) const noexcept { + VkResult writeMicromapsPropertiesEXT(uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride) const noexcept + { return fp_vkWriteMicromapsPropertiesEXT(device, micromapCount, pMicromaps, queryType, dataSize, pData, stride); } #endif #if (defined(VK_EXT_opacity_micromap)) - void getDeviceMicromapCompatibilityEXT(const VkMicromapVersionInfoEXT* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) const noexcept { + void getDeviceMicromapCompatibilityEXT(const VkMicromapVersionInfoEXT* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility) const noexcept + { fp_vkGetDeviceMicromapCompatibilityEXT(device, pVersionInfo, pCompatibility); } #endif #if (defined(VK_EXT_opacity_micromap)) - void getMicromapBuildSizesEXT(VkAccelerationStructureBuildTypeKHR buildType, const VkMicromapBuildInfoEXT* pBuildInfo, VkMicromapBuildSizesInfoEXT* pSizeInfo) const noexcept { + void getMicromapBuildSizesEXT(VkAccelerationStructureBuildTypeKHR buildType, + const VkMicromapBuildInfoEXT* pBuildInfo, + VkMicromapBuildSizesInfoEXT* pSizeInfo) const noexcept + { fp_vkGetMicromapBuildSizesEXT(device, buildType, pBuildInfo, pSizeInfo); } #endif #if (defined(VK_EXT_shader_module_identifier)) - void getShaderModuleIdentifierEXT(VkShaderModule shaderModule, VkShaderModuleIdentifierEXT* pIdentifier) const noexcept { + void getShaderModuleIdentifierEXT(VkShaderModule shaderModule, + VkShaderModuleIdentifierEXT* pIdentifier) const noexcept + { fp_vkGetShaderModuleIdentifierEXT(device, shaderModule, pIdentifier); } #endif #if (defined(VK_EXT_shader_module_identifier)) - void getShaderModuleCreateInfoIdentifierEXT(const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModuleIdentifierEXT* pIdentifier) const noexcept { + void getShaderModuleCreateInfoIdentifierEXT(const VkShaderModuleCreateInfo* pCreateInfo, + VkShaderModuleIdentifierEXT* pIdentifier) const noexcept + { fp_vkGetShaderModuleCreateInfoIdentifierEXT(device, pCreateInfo, pIdentifier); } #endif #if (defined(VK_KHR_maintenance5)) - void getImageSubresourceLayout2KHR(VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout) const noexcept { + void getImageSubresourceLayout2KHR(VkImage image, + const VkImageSubresource2EXT* pSubresource, + VkSubresourceLayout2EXT* pLayout) const noexcept + { fp_vkGetImageSubresourceLayout2KHR(device, image, pSubresource, pLayout); } #endif #if (defined(VK_EXT_pipeline_properties)) - VkResult getPipelinePropertiesEXT(const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties) const noexcept { + VkResult getPipelinePropertiesEXT(const VkPipelineInfoEXT* pPipelineInfo, + VkBaseOutStructure* pPipelineProperties) const noexcept + { return fp_vkGetPipelinePropertiesEXT(device, pPipelineInfo, pPipelineProperties); } #endif #if (defined(VK_EXT_metal_objects)) - void exportMetalObjectsEXT(VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) const noexcept { + void exportMetalObjectsEXT(VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) const noexcept + { fp_vkExportMetalObjectsEXT(device, pMetalObjectsInfo); } #endif #if (defined(VK_QCOM_tile_properties)) - VkResult getFramebufferTilePropertiesQCOM(VkFramebuffer framebuffer, uint32_t* pPropertiesCount, VkTilePropertiesQCOM* pProperties) const noexcept { + VkResult getFramebufferTilePropertiesQCOM(VkFramebuffer framebuffer, + uint32_t* pPropertiesCount, + VkTilePropertiesQCOM* pProperties) const noexcept + { return fp_vkGetFramebufferTilePropertiesQCOM(device, framebuffer, pPropertiesCount, pProperties); } #endif #if (defined(VK_QCOM_tile_properties)) - VkResult getDynamicRenderingTilePropertiesQCOM(const VkRenderingInfoKHR* pRenderingInfo, VkTilePropertiesQCOM* pProperties) const noexcept { + VkResult getDynamicRenderingTilePropertiesQCOM(const VkRenderingInfoKHR* pRenderingInfo, + VkTilePropertiesQCOM* pProperties) const noexcept + { return fp_vkGetDynamicRenderingTilePropertiesQCOM(device, pRenderingInfo, pProperties); } #endif #if (defined(VK_NV_optical_flow)) - VkResult createOpticalFlowSessionNV(const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkOpticalFlowSessionNV* pSession) const noexcept { + VkResult createOpticalFlowSessionNV(const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkOpticalFlowSessionNV* pSession) const noexcept + { return fp_vkCreateOpticalFlowSessionNV(device, pCreateInfo, pAllocator, pSession); } #endif #if (defined(VK_NV_optical_flow)) - void destroyOpticalFlowSessionNV(VkOpticalFlowSessionNV session, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyOpticalFlowSessionNV(VkOpticalFlowSessionNV session, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyOpticalFlowSessionNV(device, session, pAllocator); } #endif #if (defined(VK_NV_optical_flow)) - VkResult bindOpticalFlowSessionImageNV(VkOpticalFlowSessionNV session, VkOpticalFlowSessionBindingPointNV bindingPoint, VkImageView view, VkImageLayout layout) const noexcept { + VkResult bindOpticalFlowSessionImageNV(VkOpticalFlowSessionNV session, + VkOpticalFlowSessionBindingPointNV bindingPoint, + VkImageView view, + VkImageLayout layout) const noexcept + { return fp_vkBindOpticalFlowSessionImageNV(device, session, bindingPoint, view, layout); } #endif #if (defined(VK_NV_optical_flow)) - void cmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, VkOpticalFlowSessionNV session, const VkOpticalFlowExecuteInfoNV* pExecuteInfo) const noexcept { + void cmdOpticalFlowExecuteNV(VkCommandBuffer commandBuffer, + VkOpticalFlowSessionNV session, + const VkOpticalFlowExecuteInfoNV* pExecuteInfo) const noexcept + { fp_vkCmdOpticalFlowExecuteNV(commandBuffer, session, pExecuteInfo); } #endif #if (defined(VK_EXT_device_fault)) - VkResult getDeviceFaultInfoEXT(VkDeviceFaultCountsEXT* pFaultCounts, VkDeviceFaultInfoEXT* pFaultInfo) const noexcept { + VkResult getDeviceFaultInfoEXT(VkDeviceFaultCountsEXT* pFaultCounts, + VkDeviceFaultInfoEXT* pFaultInfo) const noexcept + { return fp_vkGetDeviceFaultInfoEXT(device, pFaultCounts, pFaultInfo); } #endif #if (defined(VK_EXT_depth_bias_control)) - void cmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo) const noexcept { + void cmdSetDepthBias2EXT(VkCommandBuffer commandBuffer, const VkDepthBiasInfoEXT* pDepthBiasInfo) const noexcept + { fp_vkCmdSetDepthBias2EXT(commandBuffer, pDepthBiasInfo); } #endif #if (defined(VK_EXT_swapchain_maintenance1)) - VkResult releaseSwapchainImagesEXT(const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) const noexcept { + VkResult releaseSwapchainImagesEXT(const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) const noexcept + { return fp_vkReleaseSwapchainImagesEXT(device, pReleaseInfo); } #endif #if (defined(VK_KHR_maintenance5)) - void getDeviceImageSubresourceLayoutKHR(const VkDeviceImageSubresourceInfoKHR* pInfo, VkSubresourceLayout2EXT* pLayout) const noexcept { + void getDeviceImageSubresourceLayoutKHR(const VkDeviceImageSubresourceInfoKHR* pInfo, + VkSubresourceLayout2EXT* pLayout) const noexcept + { fp_vkGetDeviceImageSubresourceLayoutKHR(device, pInfo, pLayout); } #endif #if (defined(VK_KHR_map_memory2)) - VkResult mapMemory2KHR(const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData) const noexcept { + VkResult mapMemory2KHR(const VkMemoryMapInfoKHR* pMemoryMapInfo, void** ppData) const noexcept + { return fp_vkMapMemory2KHR(device, pMemoryMapInfo, ppData); } #endif #if (defined(VK_KHR_map_memory2)) - VkResult unmapMemory2KHR(const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo) const noexcept { + VkResult unmapMemory2KHR(const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo) const noexcept + { return fp_vkUnmapMemory2KHR(device, pMemoryUnmapInfo); } #endif #if (defined(VK_EXT_shader_object)) - VkResult createShadersEXT(uint32_t createInfoCount, const VkShaderCreateInfoEXT* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkShaderEXT* pShaders) const noexcept { + VkResult createShadersEXT(uint32_t createInfoCount, + const VkShaderCreateInfoEXT* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkShaderEXT* pShaders) const noexcept + { return fp_vkCreateShadersEXT(device, createInfoCount, pCreateInfos, pAllocator, pShaders); } #endif #if (defined(VK_EXT_shader_object)) - void destroyShaderEXT(VkShaderEXT shader, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyShaderEXT(VkShaderEXT shader, const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyShaderEXT(device, shader, pAllocator); } #endif #if (defined(VK_EXT_shader_object)) - VkResult getShaderBinaryDataEXT(VkShaderEXT shader, size_t* pDataSize, void* pData) const noexcept { + VkResult getShaderBinaryDataEXT(VkShaderEXT shader, size_t* pDataSize, void* pData) const noexcept + { return fp_vkGetShaderBinaryDataEXT(device, shader, pDataSize, pData); } #endif #if (defined(VK_EXT_shader_object)) - void cmdBindShadersEXT(VkCommandBuffer commandBuffer, uint32_t stageCount, const VkShaderStageFlagBits* pStages, const VkShaderEXT* pShaders) const noexcept { + void cmdBindShadersEXT(VkCommandBuffer commandBuffer, + uint32_t stageCount, + const VkShaderStageFlagBits* pStages, + const VkShaderEXT* pShaders) const noexcept + { fp_vkCmdBindShadersEXT(commandBuffer, stageCount, pStages, pShaders); } #endif #if (defined(VK_QNX_external_memory_screen_buffer)) - VkResult getScreenBufferPropertiesQNX(const struct _screen_buffer* buffer, VkScreenBufferPropertiesQNX* pProperties) const noexcept { + VkResult getScreenBufferPropertiesQNX(const struct _screen_buffer* buffer, + VkScreenBufferPropertiesQNX* pProperties) const noexcept + { return fp_vkGetScreenBufferPropertiesQNX(device, buffer, pProperties); } #endif #if (defined(VK_AMDX_shader_enqueue)) - VkResult getExecutionGraphPipelineScratchSizeAMDX(VkPipeline executionGraph, VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo) const noexcept { + VkResult getExecutionGraphPipelineScratchSizeAMDX(VkPipeline executionGraph, + VkExecutionGraphPipelineScratchSizeAMDX* pSizeInfo) const noexcept + { return fp_vkGetExecutionGraphPipelineScratchSizeAMDX(device, executionGraph, pSizeInfo); } #endif #if (defined(VK_AMDX_shader_enqueue)) - VkResult getExecutionGraphPipelineNodeIndexAMDX(VkPipeline executionGraph, const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, uint32_t* pNodeIndex) const noexcept { + VkResult getExecutionGraphPipelineNodeIndexAMDX(VkPipeline executionGraph, + const VkPipelineShaderStageNodeCreateInfoAMDX* pNodeInfo, + uint32_t* pNodeIndex) const noexcept + { return fp_vkGetExecutionGraphPipelineNodeIndexAMDX(device, executionGraph, pNodeInfo, pNodeIndex); } #endif #if (defined(VK_AMDX_shader_enqueue)) - VkResult createExecutionGraphPipelinesAMDX(VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) const noexcept { - return fp_vkCreateExecutionGraphPipelinesAMDX(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + VkResult createExecutionGraphPipelinesAMDX(VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkExecutionGraphPipelineCreateInfoAMDX* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) const noexcept + { + return fp_vkCreateExecutionGraphPipelinesAMDX( + device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); } #endif #if ((defined(VK_AMDX_shader_enqueue))) && VK_HEADER_VERSION >= 298 - void cmdInitializeGraphScratchMemoryAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch) const noexcept { + void cmdInitializeGraphScratchMemoryAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch) const noexcept + { fp_vkCmdInitializeGraphScratchMemoryAMDX(commandBuffer, scratch); } #endif #if ((defined(VK_AMDX_shader_enqueue))) && VK_HEADER_VERSION >= 298 - void cmdDispatchGraphAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, const VkDispatchGraphCountInfoAMDX* pCountInfo) const noexcept { + void cmdDispatchGraphAMDX(VkCommandBuffer commandBuffer, + VkDeviceAddress scratch, + const VkDispatchGraphCountInfoAMDX* pCountInfo) const noexcept + { fp_vkCmdDispatchGraphAMDX(commandBuffer, scratch, pCountInfo); } #endif #if ((defined(VK_AMDX_shader_enqueue))) && VK_HEADER_VERSION >= 298 - void cmdDispatchGraphIndirectAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, const VkDispatchGraphCountInfoAMDX* pCountInfo) const noexcept { + void cmdDispatchGraphIndirectAMDX(VkCommandBuffer commandBuffer, + VkDeviceAddress scratch, + const VkDispatchGraphCountInfoAMDX* pCountInfo) const noexcept + { fp_vkCmdDispatchGraphIndirectAMDX(commandBuffer, scratch, pCountInfo); } #endif #if ((defined(VK_AMDX_shader_enqueue))) && VK_HEADER_VERSION >= 298 - void cmdDispatchGraphIndirectCountAMDX(VkCommandBuffer commandBuffer, VkDeviceAddress scratch, VkDeviceAddress countInfo) const noexcept { + void cmdDispatchGraphIndirectCountAMDX(VkCommandBuffer commandBuffer, + VkDeviceAddress scratch, + VkDeviceAddress countInfo) const noexcept + { fp_vkCmdDispatchGraphIndirectCountAMDX(commandBuffer, scratch, countInfo); } #endif #if (defined(VK_KHR_maintenance6)) - void cmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo) const noexcept { + void cmdBindDescriptorSets2KHR(VkCommandBuffer commandBuffer, + const VkBindDescriptorSetsInfoKHR* pBindDescriptorSetsInfo) const noexcept + { fp_vkCmdBindDescriptorSets2KHR(commandBuffer, pBindDescriptorSetsInfo); } #endif #if (defined(VK_KHR_maintenance6)) - void cmdPushConstants2KHR(VkCommandBuffer commandBuffer, const VkPushConstantsInfoKHR* pPushConstantsInfo) const noexcept { + void cmdPushConstants2KHR(VkCommandBuffer commandBuffer, + const VkPushConstantsInfoKHR* pPushConstantsInfo) const noexcept + { fp_vkCmdPushConstants2KHR(commandBuffer, pPushConstantsInfo); } #endif #if (defined(VK_KHR_maintenance6)) - void cmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo) const noexcept { + void cmdPushDescriptorSet2KHR(VkCommandBuffer commandBuffer, + const VkPushDescriptorSetInfoKHR* pPushDescriptorSetInfo) const noexcept + { fp_vkCmdPushDescriptorSet2KHR(commandBuffer, pPushDescriptorSetInfo); } #endif #if (defined(VK_KHR_maintenance6)) - void cmdPushDescriptorSetWithTemplate2KHR(VkCommandBuffer commandBuffer, const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo) const noexcept { + void cmdPushDescriptorSetWithTemplate2KHR( + VkCommandBuffer commandBuffer, + const VkPushDescriptorSetWithTemplateInfoKHR* pPushDescriptorSetWithTemplateInfo) const noexcept + { fp_vkCmdPushDescriptorSetWithTemplate2KHR(commandBuffer, pPushDescriptorSetWithTemplateInfo); } #endif #if (defined(VK_KHR_maintenance6)) - void cmdSetDescriptorBufferOffsets2EXT(VkCommandBuffer commandBuffer, const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) const noexcept { + void cmdSetDescriptorBufferOffsets2EXT( + VkCommandBuffer commandBuffer, + const VkSetDescriptorBufferOffsetsInfoEXT* pSetDescriptorBufferOffsetsInfo) const noexcept + { fp_vkCmdSetDescriptorBufferOffsets2EXT(commandBuffer, pSetDescriptorBufferOffsetsInfo); } #endif #if (defined(VK_KHR_maintenance6)) - void cmdBindDescriptorBufferEmbeddedSamplers2EXT(VkCommandBuffer commandBuffer, const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) const noexcept { + void cmdBindDescriptorBufferEmbeddedSamplers2EXT( + VkCommandBuffer commandBuffer, + const VkBindDescriptorBufferEmbeddedSamplersInfoEXT* pBindDescriptorBufferEmbeddedSamplersInfo) const noexcept + { fp_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT(commandBuffer, pBindDescriptorBufferEmbeddedSamplersInfo); } #endif #if (defined(VK_NV_low_latency2)) - VkResult setLatencySleepModeNV(VkSwapchainKHR swapchain, const VkLatencySleepModeInfoNV* pSleepModeInfo) const noexcept { + VkResult setLatencySleepModeNV(VkSwapchainKHR swapchain, + const VkLatencySleepModeInfoNV* pSleepModeInfo) const noexcept + { return fp_vkSetLatencySleepModeNV(device, swapchain, pSleepModeInfo); } #endif #if (defined(VK_NV_low_latency2)) - VkResult latencySleepNV(VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo) const noexcept { + VkResult latencySleepNV(VkSwapchainKHR swapchain, const VkLatencySleepInfoNV* pSleepInfo) const noexcept + { return fp_vkLatencySleepNV(device, swapchain, pSleepInfo); } #endif #if (defined(VK_NV_low_latency2)) - void setLatencyMarkerNV(VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) const noexcept { + void setLatencyMarkerNV(VkSwapchainKHR swapchain, const VkSetLatencyMarkerInfoNV* pLatencyMarkerInfo) const noexcept + { fp_vkSetLatencyMarkerNV(device, swapchain, pLatencyMarkerInfo); } #endif #if ((defined(VK_NV_low_latency2))) && VK_HEADER_VERSION >= 271 - void getLatencyTimingsNV(VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) const noexcept { + void getLatencyTimingsNV(VkSwapchainKHR swapchain, VkGetLatencyMarkerInfoNV* pLatencyMarkerInfo) const noexcept + { fp_vkGetLatencyTimingsNV(device, swapchain, pLatencyMarkerInfo); } #endif #if (defined(VK_NV_low_latency2)) - void queueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo) const noexcept { + void queueNotifyOutOfBandNV(VkQueue queue, const VkOutOfBandQueueTypeInfoNV* pQueueTypeInfo) const noexcept + { fp_vkQueueNotifyOutOfBandNV(queue, pQueueTypeInfo); } #endif #if (defined(VK_KHR_dynamic_rendering_local_read)) - void cmdSetRenderingAttachmentLocationsKHR(VkCommandBuffer commandBuffer, const VkRenderingAttachmentLocationInfoKHR* pLocationInfo) const noexcept { + void cmdSetRenderingAttachmentLocationsKHR(VkCommandBuffer commandBuffer, + const VkRenderingAttachmentLocationInfoKHR* pLocationInfo) const noexcept + { fp_vkCmdSetRenderingAttachmentLocationsKHR(commandBuffer, pLocationInfo); } #endif #if (defined(VK_KHR_dynamic_rendering_local_read)) - void cmdSetRenderingInputAttachmentIndicesKHR(VkCommandBuffer commandBuffer, const VkRenderingInputAttachmentIndexInfoKHR* pInputAttachmentIndexInfo) const noexcept { + void cmdSetRenderingInputAttachmentIndicesKHR( + VkCommandBuffer commandBuffer, + const VkRenderingInputAttachmentIndexInfoKHR* pInputAttachmentIndexInfo) const noexcept + { fp_vkCmdSetRenderingInputAttachmentIndicesKHR(commandBuffer, pInputAttachmentIndexInfo); } #endif #if (defined(VK_EXT_shader_object)) || (defined(VK_EXT_depth_clamp_control)) - void cmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, VkDepthClampModeEXT depthClampMode, const VkDepthClampRangeEXT* pDepthClampRange) const noexcept { + void cmdSetDepthClampRangeEXT(VkCommandBuffer commandBuffer, + VkDepthClampModeEXT depthClampMode, + const VkDepthClampRangeEXT* pDepthClampRange) const noexcept + { fp_vkCmdSetDepthClampRangeEXT(commandBuffer, depthClampMode, pDepthClampRange); } #endif #if (defined(VK_EXT_host_query_reset)) - void resetQueryPoolEXT(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const noexcept { + void resetQueryPoolEXT(VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) const noexcept + { fp_vkResetQueryPoolEXT(device, queryPool, firstQuery, queryCount); } #endif #if (defined(VK_KHR_maintenance1)) - void trimCommandPoolKHR(VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags) const noexcept { + void trimCommandPoolKHR(VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags) const noexcept + { fp_vkTrimCommandPoolKHR(device, commandPool, flags); } #endif #if (defined(VK_KHR_device_group)) - void getDeviceGroupPeerMemoryFeaturesKHR(uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlagsKHR* pPeerMemoryFeatures) const noexcept { - fp_vkGetDeviceGroupPeerMemoryFeaturesKHR(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); + void getDeviceGroupPeerMemoryFeaturesKHR(uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlagsKHR* pPeerMemoryFeatures) const noexcept + { + fp_vkGetDeviceGroupPeerMemoryFeaturesKHR( + device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); } #endif #if (defined(VK_KHR_bind_memory2)) - VkResult bindBufferMemory2KHR(uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHR* pBindInfos) const noexcept { + VkResult bindBufferMemory2KHR(uint32_t bindInfoCount, const VkBindBufferMemoryInfoKHR* pBindInfos) const noexcept + { return fp_vkBindBufferMemory2KHR(device, bindInfoCount, pBindInfos); } #endif #if (defined(VK_KHR_bind_memory2)) - VkResult bindImageMemory2KHR(uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos) const noexcept { + VkResult bindImageMemory2KHR(uint32_t bindInfoCount, const VkBindImageMemoryInfoKHR* pBindInfos) const noexcept + { return fp_vkBindImageMemory2KHR(device, bindInfoCount, pBindInfos); } #endif #if (defined(VK_KHR_device_group)) - void cmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) const noexcept { + void cmdSetDeviceMaskKHR(VkCommandBuffer commandBuffer, uint32_t deviceMask) const noexcept + { fp_vkCmdSetDeviceMaskKHR(commandBuffer, deviceMask); } #endif #if (defined(VK_KHR_device_group)) - void cmdDispatchBaseKHR(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) const noexcept { - fp_vkCmdDispatchBaseKHR(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); + void cmdDispatchBaseKHR(VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ) const noexcept + { + fp_vkCmdDispatchBaseKHR( + commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); } #endif #if (defined(VK_KHR_descriptor_update_template)) - VkResult createDescriptorUpdateTemplateKHR(const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate) const noexcept { + VkResult createDescriptorUpdateTemplateKHR(const VkDescriptorUpdateTemplateCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplateKHR* pDescriptorUpdateTemplate) const noexcept + { return fp_vkCreateDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); } #endif #if (defined(VK_KHR_descriptor_update_template)) - void destroyDescriptorUpdateTemplateKHR(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyDescriptorUpdateTemplateKHR(VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyDescriptorUpdateTemplateKHR(device, descriptorUpdateTemplate, pAllocator); } #endif #if (defined(VK_KHR_descriptor_update_template)) - void updateDescriptorSetWithTemplateKHR(VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, const void* pData) const noexcept { + void updateDescriptorSetWithTemplateKHR(VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplateKHR descriptorUpdateTemplate, + const void* pData) const noexcept + { fp_vkUpdateDescriptorSetWithTemplateKHR(device, descriptorSet, descriptorUpdateTemplate, pData); } #endif #if (defined(VK_KHR_get_memory_requirements2)) - void getBufferMemoryRequirements2KHR(const VkBufferMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept { + void getBufferMemoryRequirements2KHR(const VkBufferMemoryRequirementsInfo2KHR* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept + { fp_vkGetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } #endif #if (defined(VK_KHR_get_memory_requirements2)) - void getImageMemoryRequirements2KHR(const VkImageMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept { + void getImageMemoryRequirements2KHR(const VkImageMemoryRequirementsInfo2KHR* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept + { fp_vkGetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); } #endif #if (defined(VK_KHR_get_memory_requirements2)) - void getImageSparseMemoryRequirements2KHR(const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements) const noexcept { - fp_vkGetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + void + getImageSparseMemoryRequirements2KHR(const VkImageSparseMemoryRequirementsInfo2KHR* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements) const noexcept + { + fp_vkGetImageSparseMemoryRequirements2KHR( + device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } #endif #if (defined(VK_KHR_maintenance4)) - void getDeviceBufferMemoryRequirementsKHR(const VkDeviceBufferMemoryRequirementsKHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept { + void getDeviceBufferMemoryRequirementsKHR(const VkDeviceBufferMemoryRequirementsKHR* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept + { fp_vkGetDeviceBufferMemoryRequirementsKHR(device, pInfo, pMemoryRequirements); } #endif #if (defined(VK_KHR_maintenance4)) - void getDeviceImageMemoryRequirementsKHR(const VkDeviceImageMemoryRequirementsKHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept { + void getDeviceImageMemoryRequirementsKHR(const VkDeviceImageMemoryRequirementsKHR* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements) const noexcept + { fp_vkGetDeviceImageMemoryRequirementsKHR(device, pInfo, pMemoryRequirements); } #endif #if (defined(VK_KHR_maintenance4)) - void getDeviceImageSparseMemoryRequirementsKHR(const VkDeviceImageMemoryRequirementsKHR* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements) const noexcept { - fp_vkGetDeviceImageSparseMemoryRequirementsKHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + void getDeviceImageSparseMemoryRequirementsKHR( + const VkDeviceImageMemoryRequirementsKHR* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2KHR* pSparseMemoryRequirements) const noexcept + { + fp_vkGetDeviceImageSparseMemoryRequirementsKHR( + device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); } #endif #if (defined(VK_KHR_sampler_ycbcr_conversion)) - VkResult createSamplerYcbcrConversionKHR(const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversionKHR* pYcbcrConversion) const noexcept { + VkResult createSamplerYcbcrConversionKHR(const VkSamplerYcbcrConversionCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversionKHR* pYcbcrConversion) const noexcept + { return fp_vkCreateSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, pYcbcrConversion); } #endif #if (defined(VK_KHR_sampler_ycbcr_conversion)) - void destroySamplerYcbcrConversionKHR(VkSamplerYcbcrConversionKHR ycbcrConversion, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroySamplerYcbcrConversionKHR(VkSamplerYcbcrConversionKHR ycbcrConversion, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroySamplerYcbcrConversionKHR(device, ycbcrConversion, pAllocator); } #endif #if (defined(VK_KHR_maintenance3)) - void getDescriptorSetLayoutSupportKHR(const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupportKHR* pSupport) const noexcept { + void getDescriptorSetLayoutSupportKHR(const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupportKHR* pSupport) const noexcept + { fp_vkGetDescriptorSetLayoutSupportKHR(device, pCreateInfo, pSupport); } #endif #if (defined(VK_EXT_calibrated_timestamps)) - VkResult getCalibratedTimestampsEXT(uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) const noexcept { + VkResult getCalibratedTimestampsEXT(uint32_t timestampCount, + const VkCalibratedTimestampInfoEXT* pTimestampInfos, + uint64_t* pTimestamps, + uint64_t* pMaxDeviation) const noexcept + { return fp_vkGetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); } #endif #if (defined(VK_KHR_create_renderpass2)) - VkResult createRenderPass2KHR(const VkRenderPassCreateInfo2KHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) const noexcept { + VkResult createRenderPass2KHR(const VkRenderPassCreateInfo2KHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass) const noexcept + { return fp_vkCreateRenderPass2KHR(device, pCreateInfo, pAllocator, pRenderPass); } #endif #if (defined(VK_KHR_create_renderpass2)) - void cmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfoKHR* pSubpassBeginInfo) const noexcept { + void cmdBeginRenderPass2KHR(VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfoKHR* pSubpassBeginInfo) const noexcept + { fp_vkCmdBeginRenderPass2KHR(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); } #endif #if (defined(VK_KHR_create_renderpass2)) - void cmdNextSubpass2KHR(VkCommandBuffer commandBuffer, const VkSubpassBeginInfoKHR* pSubpassBeginInfo, const VkSubpassEndInfoKHR* pSubpassEndInfo) const noexcept { + void cmdNextSubpass2KHR(VkCommandBuffer commandBuffer, + const VkSubpassBeginInfoKHR* pSubpassBeginInfo, + const VkSubpassEndInfoKHR* pSubpassEndInfo) const noexcept + { fp_vkCmdNextSubpass2KHR(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); } #endif #if (defined(VK_KHR_create_renderpass2)) - void cmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo) const noexcept { + void cmdEndRenderPass2KHR(VkCommandBuffer commandBuffer, const VkSubpassEndInfoKHR* pSubpassEndInfo) const noexcept + { fp_vkCmdEndRenderPass2KHR(commandBuffer, pSubpassEndInfo); } #endif #if (defined(VK_KHR_timeline_semaphore)) - VkResult getSemaphoreCounterValueKHR(VkSemaphore semaphore, uint64_t* pValue) const noexcept { + VkResult getSemaphoreCounterValueKHR(VkSemaphore semaphore, uint64_t* pValue) const noexcept + { return fp_vkGetSemaphoreCounterValueKHR(device, semaphore, pValue); } #endif #if (defined(VK_KHR_timeline_semaphore)) - VkResult waitSemaphoresKHR(const VkSemaphoreWaitInfoKHR* pWaitInfo, uint64_t timeout) const noexcept { + VkResult waitSemaphoresKHR(const VkSemaphoreWaitInfoKHR* pWaitInfo, uint64_t timeout) const noexcept + { return fp_vkWaitSemaphoresKHR(device, pWaitInfo, timeout); } #endif #if (defined(VK_KHR_timeline_semaphore)) - VkResult signalSemaphoreKHR(const VkSemaphoreSignalInfoKHR* pSignalInfo) const noexcept { + VkResult signalSemaphoreKHR(const VkSemaphoreSignalInfoKHR* pSignalInfo) const noexcept + { return fp_vkSignalSemaphoreKHR(device, pSignalInfo); } #endif #if (defined(VK_AMD_draw_indirect_count)) - void cmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const noexcept { - fp_vkCmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + void cmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) const noexcept + { + fp_vkCmdDrawIndirectCountAMD( + commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } #endif #if (defined(VK_AMD_draw_indirect_count)) - void cmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) const noexcept { - fp_vkCmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + void cmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) const noexcept + { + fp_vkCmdDrawIndexedIndirectCountAMD( + commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); } #endif #if (defined(VK_NV_ray_tracing)) - VkResult getRayTracingShaderGroupHandlesNV(VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) const noexcept { + VkResult getRayTracingShaderGroupHandlesNV( + VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) const noexcept + { return fp_vkGetRayTracingShaderGroupHandlesNV(device, pipeline, firstGroup, groupCount, dataSize, pData); } #endif #if (defined(VK_KHR_buffer_device_address)) - uint64_t getBufferOpaqueCaptureAddressKHR(const VkBufferDeviceAddressInfoEXT* pInfo) const noexcept { + uint64_t getBufferOpaqueCaptureAddressKHR(const VkBufferDeviceAddressInfoEXT* pInfo) const noexcept + { return fp_vkGetBufferOpaqueCaptureAddressKHR(device, pInfo); } #endif #if (defined(VK_EXT_buffer_device_address)) - VkDeviceAddress getBufferDeviceAddressEXT(const VkBufferDeviceAddressInfoEXT* pInfo) const noexcept { + VkDeviceAddress getBufferDeviceAddressEXT(const VkBufferDeviceAddressInfoEXT* pInfo) const noexcept + { return fp_vkGetBufferDeviceAddressEXT(device, pInfo); } #endif #if (defined(VK_KHR_buffer_device_address)) - uint64_t getDeviceMemoryOpaqueCaptureAddressKHR(const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo) const noexcept { + uint64_t + getDeviceMemoryOpaqueCaptureAddressKHR(const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo) const noexcept + { return fp_vkGetDeviceMemoryOpaqueCaptureAddressKHR(device, pInfo); } #endif #if (defined(VK_EXT_line_rasterization)) - void cmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) const noexcept { + void cmdSetLineStippleEXT(VkCommandBuffer commandBuffer, + uint32_t lineStippleFactor, + uint16_t lineStipplePattern) const noexcept + { fp_vkCmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); } #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - void cmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const noexcept { + void cmdSetCullModeEXT(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) const noexcept + { fp_vkCmdSetCullModeEXT(commandBuffer, cullMode); } #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - void cmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) const noexcept { + void cmdSetFrontFaceEXT(VkCommandBuffer commandBuffer, VkFrontFace frontFace) const noexcept + { fp_vkCmdSetFrontFaceEXT(commandBuffer, frontFace); } #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - void cmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const noexcept { + void cmdSetPrimitiveTopologyEXT(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) const noexcept + { fp_vkCmdSetPrimitiveTopologyEXT(commandBuffer, primitiveTopology); } #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - void cmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) const noexcept { + void cmdSetViewportWithCountEXT(VkCommandBuffer commandBuffer, + uint32_t viewportCount, + const VkViewport* pViewports) const noexcept + { fp_vkCmdSetViewportWithCountEXT(commandBuffer, viewportCount, pViewports); } #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - void cmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) const noexcept { + void cmdSetScissorWithCountEXT(VkCommandBuffer commandBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors) const noexcept + { fp_vkCmdSetScissorWithCountEXT(commandBuffer, scissorCount, pScissors); } #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - void cmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) const noexcept { + void cmdBindVertexBuffers2EXT(VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides) const noexcept + { fp_vkCmdBindVertexBuffers2EXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); } #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - void cmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const noexcept { + void cmdSetDepthTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) const noexcept + { fp_vkCmdSetDepthTestEnableEXT(commandBuffer, depthTestEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - void cmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const noexcept { + void cmdSetDepthWriteEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) const noexcept + { fp_vkCmdSetDepthWriteEnableEXT(commandBuffer, depthWriteEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - void cmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const noexcept { + void cmdSetDepthCompareOpEXT(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) const noexcept + { fp_vkCmdSetDepthCompareOpEXT(commandBuffer, depthCompareOp); } #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - void cmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const noexcept { + void cmdSetDepthBoundsTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) const noexcept + { fp_vkCmdSetDepthBoundsTestEnableEXT(commandBuffer, depthBoundsTestEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - void cmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const noexcept { + void cmdSetStencilTestEnableEXT(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) const noexcept + { fp_vkCmdSetStencilTestEnableEXT(commandBuffer, stencilTestEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) - void cmdSetStencilOpEXT(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) const noexcept { + void cmdSetStencilOpEXT(VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp) const noexcept + { fp_vkCmdSetStencilOpEXT(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); } #endif #if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) - void cmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) const noexcept { + void cmdSetRasterizerDiscardEnableEXT(VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable) const noexcept + { fp_vkCmdSetRasterizerDiscardEnableEXT(commandBuffer, rasterizerDiscardEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) - void cmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const noexcept { + void cmdSetDepthBiasEnableEXT(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) const noexcept + { fp_vkCmdSetDepthBiasEnableEXT(commandBuffer, depthBiasEnable); } #endif #if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) - void cmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const noexcept { + void cmdSetPrimitiveRestartEnableEXT(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) const noexcept + { fp_vkCmdSetPrimitiveRestartEnableEXT(commandBuffer, primitiveRestartEnable); } #endif #if (defined(VK_EXT_private_data)) - VkResult createPrivateDataSlotEXT(const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlotEXT* pPrivateDataSlot) const noexcept { + VkResult createPrivateDataSlotEXT(const VkPrivateDataSlotCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlotEXT* pPrivateDataSlot) const noexcept + { return fp_vkCreatePrivateDataSlotEXT(device, pCreateInfo, pAllocator, pPrivateDataSlot); } #endif #if (defined(VK_EXT_private_data)) - void destroyPrivateDataSlotEXT(VkPrivateDataSlotEXT privateDataSlot, const VkAllocationCallbacks* pAllocator) const noexcept { + void destroyPrivateDataSlotEXT(VkPrivateDataSlotEXT privateDataSlot, + const VkAllocationCallbacks* pAllocator) const noexcept + { fp_vkDestroyPrivateDataSlotEXT(device, privateDataSlot, pAllocator); } #endif #if (defined(VK_EXT_private_data)) - VkResult setPrivateDataEXT(VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t data) const noexcept { + VkResult setPrivateDataEXT(VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlotEXT privateDataSlot, + uint64_t data) const noexcept + { return fp_vkSetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, data); } #endif #if (defined(VK_EXT_private_data)) - void getPrivateDataEXT(VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlotEXT privateDataSlot, uint64_t* pData) const noexcept { + void getPrivateDataEXT(VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlotEXT privateDataSlot, + uint64_t* pData) const noexcept + { fp_vkGetPrivateDataEXT(device, objectType, objectHandle, privateDataSlot, pData); } #endif #if (defined(VK_KHR_copy_commands2)) - void cmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR* pCopyBufferInfo) const noexcept { + void cmdCopyBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2KHR* pCopyBufferInfo) const noexcept + { fp_vkCmdCopyBuffer2KHR(commandBuffer, pCopyBufferInfo); } #endif #if (defined(VK_KHR_copy_commands2)) - void cmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR* pCopyImageInfo) const noexcept { + void cmdCopyImage2KHR(VkCommandBuffer commandBuffer, const VkCopyImageInfo2KHR* pCopyImageInfo) const noexcept + { fp_vkCmdCopyImage2KHR(commandBuffer, pCopyImageInfo); } #endif #if (defined(VK_KHR_copy_commands2)) - void cmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR* pBlitImageInfo) const noexcept { + void cmdBlitImage2KHR(VkCommandBuffer commandBuffer, const VkBlitImageInfo2KHR* pBlitImageInfo) const noexcept + { fp_vkCmdBlitImage2KHR(commandBuffer, pBlitImageInfo); } #endif #if (defined(VK_KHR_copy_commands2)) - void cmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo) const noexcept { + void cmdCopyBufferToImage2KHR(VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2KHR* pCopyBufferToImageInfo) const noexcept + { fp_vkCmdCopyBufferToImage2KHR(commandBuffer, pCopyBufferToImageInfo); } #endif #if (defined(VK_KHR_copy_commands2)) - void cmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo) const noexcept { + void cmdCopyImageToBuffer2KHR(VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2KHR* pCopyImageToBufferInfo) const noexcept + { fp_vkCmdCopyImageToBuffer2KHR(commandBuffer, pCopyImageToBufferInfo); } #endif #if (defined(VK_KHR_copy_commands2)) - void cmdResolveImage2KHR(VkCommandBuffer commandBuffer, const VkResolveImageInfo2KHR* pResolveImageInfo) const noexcept { + void cmdResolveImage2KHR(VkCommandBuffer commandBuffer, + const VkResolveImageInfo2KHR* pResolveImageInfo) const noexcept + { fp_vkCmdResolveImage2KHR(commandBuffer, pResolveImageInfo); } #endif #if (defined(VK_KHR_synchronization2)) - void cmdSetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfoKHR* pDependencyInfo) const noexcept { + void cmdSetEvent2KHR(VkCommandBuffer commandBuffer, + VkEvent event, + const VkDependencyInfoKHR* pDependencyInfo) const noexcept + { fp_vkCmdSetEvent2KHR(commandBuffer, event, pDependencyInfo); } #endif #if (defined(VK_KHR_synchronization2)) - void cmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask) const noexcept { + void + cmdResetEvent2KHR(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2KHR stageMask) const noexcept + { fp_vkCmdResetEvent2KHR(commandBuffer, event, stageMask); } #endif #if (defined(VK_KHR_synchronization2)) - void cmdWaitEvents2KHR(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfoKHR* pDependencyInfos) const noexcept { + void cmdWaitEvents2KHR(VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + const VkDependencyInfoKHR* pDependencyInfos) const noexcept + { fp_vkCmdWaitEvents2KHR(commandBuffer, eventCount, pEvents, pDependencyInfos); } #endif #if (defined(VK_KHR_synchronization2)) - void cmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, const VkDependencyInfoKHR* pDependencyInfo) const noexcept { + void cmdPipelineBarrier2KHR(VkCommandBuffer commandBuffer, + const VkDependencyInfoKHR* pDependencyInfo) const noexcept + { fp_vkCmdPipelineBarrier2KHR(commandBuffer, pDependencyInfo); } #endif #if (defined(VK_KHR_synchronization2)) - VkResult queueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR* pSubmits, VkFence fence) const noexcept { + VkResult + queueSubmit2KHR(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2KHR* pSubmits, VkFence fence) const noexcept + { return fp_vkQueueSubmit2KHR(queue, submitCount, pSubmits, fence); } #endif #if (defined(VK_KHR_synchronization2)) - void cmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, VkPipelineStageFlags2KHR stage, VkQueryPool queryPool, uint32_t query) const noexcept { + void cmdWriteTimestamp2KHR(VkCommandBuffer commandBuffer, + VkPipelineStageFlags2KHR stage, + VkQueryPool queryPool, + uint32_t query) const noexcept + { fp_vkCmdWriteTimestamp2KHR(commandBuffer, stage, queryPool, query); } #endif #if (defined(VK_KHR_dynamic_rendering)) - void cmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo) const noexcept { + void cmdBeginRenderingKHR(VkCommandBuffer commandBuffer, const VkRenderingInfoKHR* pRenderingInfo) const noexcept + { fp_vkCmdBeginRenderingKHR(commandBuffer, pRenderingInfo); } #endif #if (defined(VK_KHR_dynamic_rendering)) - void cmdEndRenderingKHR(VkCommandBuffer commandBuffer) const noexcept { - fp_vkCmdEndRenderingKHR(commandBuffer); - } + void cmdEndRenderingKHR(VkCommandBuffer commandBuffer) const noexcept { fp_vkCmdEndRenderingKHR(commandBuffer); } #endif #if (defined(VK_EXT_host_image_copy)) || (defined(VK_EXT_image_compression_control)) - void getImageSubresourceLayout2EXT(VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout) const noexcept { + void getImageSubresourceLayout2EXT(VkImage image, + const VkImageSubresource2EXT* pSubresource, + VkSubresourceLayout2EXT* pLayout) const noexcept + { fp_vkGetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout); } #endif - PFN_vkGetDeviceQueue fp_vkGetDeviceQueue = nullptr; - PFN_vkQueueSubmit fp_vkQueueSubmit = nullptr; - PFN_vkQueueWaitIdle fp_vkQueueWaitIdle = nullptr; - PFN_vkDeviceWaitIdle fp_vkDeviceWaitIdle = nullptr; - PFN_vkAllocateMemory fp_vkAllocateMemory = nullptr; - PFN_vkFreeMemory fp_vkFreeMemory = nullptr; - PFN_vkMapMemory fp_vkMapMemory = nullptr; - PFN_vkUnmapMemory fp_vkUnmapMemory = nullptr; - PFN_vkFlushMappedMemoryRanges fp_vkFlushMappedMemoryRanges = nullptr; - PFN_vkInvalidateMappedMemoryRanges fp_vkInvalidateMappedMemoryRanges = nullptr; - PFN_vkGetDeviceMemoryCommitment fp_vkGetDeviceMemoryCommitment = nullptr; - PFN_vkGetBufferMemoryRequirements fp_vkGetBufferMemoryRequirements = nullptr; - PFN_vkBindBufferMemory fp_vkBindBufferMemory = nullptr; - PFN_vkGetImageMemoryRequirements fp_vkGetImageMemoryRequirements = nullptr; - PFN_vkBindImageMemory fp_vkBindImageMemory = nullptr; + PFN_vkGetDeviceQueue fp_vkGetDeviceQueue = nullptr; + PFN_vkQueueSubmit fp_vkQueueSubmit = nullptr; + PFN_vkQueueWaitIdle fp_vkQueueWaitIdle = nullptr; + PFN_vkDeviceWaitIdle fp_vkDeviceWaitIdle = nullptr; + PFN_vkAllocateMemory fp_vkAllocateMemory = nullptr; + PFN_vkFreeMemory fp_vkFreeMemory = nullptr; + PFN_vkMapMemory fp_vkMapMemory = nullptr; + PFN_vkUnmapMemory fp_vkUnmapMemory = nullptr; + PFN_vkFlushMappedMemoryRanges fp_vkFlushMappedMemoryRanges = nullptr; + PFN_vkInvalidateMappedMemoryRanges fp_vkInvalidateMappedMemoryRanges = nullptr; + PFN_vkGetDeviceMemoryCommitment fp_vkGetDeviceMemoryCommitment = nullptr; + PFN_vkGetBufferMemoryRequirements fp_vkGetBufferMemoryRequirements = nullptr; + PFN_vkBindBufferMemory fp_vkBindBufferMemory = nullptr; + PFN_vkGetImageMemoryRequirements fp_vkGetImageMemoryRequirements = nullptr; + PFN_vkBindImageMemory fp_vkBindImageMemory = nullptr; PFN_vkGetImageSparseMemoryRequirements fp_vkGetImageSparseMemoryRequirements = nullptr; - PFN_vkQueueBindSparse fp_vkQueueBindSparse = nullptr; - PFN_vkCreateFence fp_vkCreateFence = nullptr; - PFN_vkDestroyFence fp_vkDestroyFence = nullptr; - PFN_vkResetFences fp_vkResetFences = nullptr; - PFN_vkGetFenceStatus fp_vkGetFenceStatus = nullptr; - PFN_vkWaitForFences fp_vkWaitForFences = nullptr; - PFN_vkCreateSemaphore fp_vkCreateSemaphore = nullptr; - PFN_vkDestroySemaphore fp_vkDestroySemaphore = nullptr; - PFN_vkCreateEvent fp_vkCreateEvent = nullptr; - PFN_vkDestroyEvent fp_vkDestroyEvent = nullptr; - PFN_vkGetEventStatus fp_vkGetEventStatus = nullptr; - PFN_vkSetEvent fp_vkSetEvent = nullptr; - PFN_vkResetEvent fp_vkResetEvent = nullptr; - PFN_vkCreateQueryPool fp_vkCreateQueryPool = nullptr; - PFN_vkDestroyQueryPool fp_vkDestroyQueryPool = nullptr; - PFN_vkGetQueryPoolResults fp_vkGetQueryPoolResults = nullptr; + PFN_vkQueueBindSparse fp_vkQueueBindSparse = nullptr; + PFN_vkCreateFence fp_vkCreateFence = nullptr; + PFN_vkDestroyFence fp_vkDestroyFence = nullptr; + PFN_vkResetFences fp_vkResetFences = nullptr; + PFN_vkGetFenceStatus fp_vkGetFenceStatus = nullptr; + PFN_vkWaitForFences fp_vkWaitForFences = nullptr; + PFN_vkCreateSemaphore fp_vkCreateSemaphore = nullptr; + PFN_vkDestroySemaphore fp_vkDestroySemaphore = nullptr; + PFN_vkCreateEvent fp_vkCreateEvent = nullptr; + PFN_vkDestroyEvent fp_vkDestroyEvent = nullptr; + PFN_vkGetEventStatus fp_vkGetEventStatus = nullptr; + PFN_vkSetEvent fp_vkSetEvent = nullptr; + PFN_vkResetEvent fp_vkResetEvent = nullptr; + PFN_vkCreateQueryPool fp_vkCreateQueryPool = nullptr; + PFN_vkDestroyQueryPool fp_vkDestroyQueryPool = nullptr; + PFN_vkGetQueryPoolResults fp_vkGetQueryPoolResults = nullptr; #if (defined(VK_VERSION_1_2)) PFN_vkResetQueryPool fp_vkResetQueryPool = nullptr; #else - void * fp_vkResetQueryPool{}; + void* fp_vkResetQueryPool{}; #endif - PFN_vkCreateBuffer fp_vkCreateBuffer = nullptr; - PFN_vkDestroyBuffer fp_vkDestroyBuffer = nullptr; - PFN_vkCreateBufferView fp_vkCreateBufferView = nullptr; - PFN_vkDestroyBufferView fp_vkDestroyBufferView = nullptr; - PFN_vkCreateImage fp_vkCreateImage = nullptr; - PFN_vkDestroyImage fp_vkDestroyImage = nullptr; + PFN_vkCreateBuffer fp_vkCreateBuffer = nullptr; + PFN_vkDestroyBuffer fp_vkDestroyBuffer = nullptr; + PFN_vkCreateBufferView fp_vkCreateBufferView = nullptr; + PFN_vkDestroyBufferView fp_vkDestroyBufferView = nullptr; + PFN_vkCreateImage fp_vkCreateImage = nullptr; + PFN_vkDestroyImage fp_vkDestroyImage = nullptr; PFN_vkGetImageSubresourceLayout fp_vkGetImageSubresourceLayout = nullptr; - PFN_vkCreateImageView fp_vkCreateImageView = nullptr; - PFN_vkDestroyImageView fp_vkDestroyImageView = nullptr; - PFN_vkCreateShaderModule fp_vkCreateShaderModule = nullptr; - PFN_vkDestroyShaderModule fp_vkDestroyShaderModule = nullptr; - PFN_vkCreatePipelineCache fp_vkCreatePipelineCache = nullptr; - PFN_vkDestroyPipelineCache fp_vkDestroyPipelineCache = nullptr; - PFN_vkGetPipelineCacheData fp_vkGetPipelineCacheData = nullptr; - PFN_vkMergePipelineCaches fp_vkMergePipelineCaches = nullptr; + PFN_vkCreateImageView fp_vkCreateImageView = nullptr; + PFN_vkDestroyImageView fp_vkDestroyImageView = nullptr; + PFN_vkCreateShaderModule fp_vkCreateShaderModule = nullptr; + PFN_vkDestroyShaderModule fp_vkDestroyShaderModule = nullptr; + PFN_vkCreatePipelineCache fp_vkCreatePipelineCache = nullptr; + PFN_vkDestroyPipelineCache fp_vkDestroyPipelineCache = nullptr; + PFN_vkGetPipelineCacheData fp_vkGetPipelineCacheData = nullptr; + PFN_vkMergePipelineCaches fp_vkMergePipelineCaches = nullptr; #if (defined(VK_KHR_pipeline_binary)) PFN_vkCreatePipelineBinariesKHR fp_vkCreatePipelineBinariesKHR = nullptr; #else - void * fp_vkCreatePipelineBinariesKHR{}; + void* fp_vkCreatePipelineBinariesKHR{}; #endif #if (defined(VK_KHR_pipeline_binary)) PFN_vkDestroyPipelineBinaryKHR fp_vkDestroyPipelineBinaryKHR = nullptr; #else - void * fp_vkDestroyPipelineBinaryKHR{}; + void* fp_vkDestroyPipelineBinaryKHR{}; #endif #if (defined(VK_KHR_pipeline_binary)) PFN_vkGetPipelineKeyKHR fp_vkGetPipelineKeyKHR = nullptr; #else - void * fp_vkGetPipelineKeyKHR{}; + void* fp_vkGetPipelineKeyKHR{}; #endif #if (defined(VK_KHR_pipeline_binary)) PFN_vkGetPipelineBinaryDataKHR fp_vkGetPipelineBinaryDataKHR = nullptr; #else - void * fp_vkGetPipelineBinaryDataKHR{}; + void* fp_vkGetPipelineBinaryDataKHR{}; #endif #if (defined(VK_KHR_pipeline_binary)) PFN_vkReleaseCapturedPipelineDataKHR fp_vkReleaseCapturedPipelineDataKHR = nullptr; #else - void * fp_vkReleaseCapturedPipelineDataKHR{}; + void* fp_vkReleaseCapturedPipelineDataKHR{}; #endif PFN_vkCreateGraphicsPipelines fp_vkCreateGraphicsPipelines = nullptr; - PFN_vkCreateComputePipelines fp_vkCreateComputePipelines = nullptr; + PFN_vkCreateComputePipelines fp_vkCreateComputePipelines = nullptr; #if (defined(VK_HUAWEI_subpass_shading)) PFN_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI fp_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI = nullptr; #else - void * fp_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI{}; + void* fp_vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI{}; #endif - PFN_vkDestroyPipeline fp_vkDestroyPipeline = nullptr; - PFN_vkCreatePipelineLayout fp_vkCreatePipelineLayout = nullptr; - PFN_vkDestroyPipelineLayout fp_vkDestroyPipelineLayout = nullptr; - PFN_vkCreateSampler fp_vkCreateSampler = nullptr; - PFN_vkDestroySampler fp_vkDestroySampler = nullptr; - PFN_vkCreateDescriptorSetLayout fp_vkCreateDescriptorSetLayout = nullptr; + PFN_vkDestroyPipeline fp_vkDestroyPipeline = nullptr; + PFN_vkCreatePipelineLayout fp_vkCreatePipelineLayout = nullptr; + PFN_vkDestroyPipelineLayout fp_vkDestroyPipelineLayout = nullptr; + PFN_vkCreateSampler fp_vkCreateSampler = nullptr; + PFN_vkDestroySampler fp_vkDestroySampler = nullptr; + PFN_vkCreateDescriptorSetLayout fp_vkCreateDescriptorSetLayout = nullptr; PFN_vkDestroyDescriptorSetLayout fp_vkDestroyDescriptorSetLayout = nullptr; - PFN_vkCreateDescriptorPool fp_vkCreateDescriptorPool = nullptr; - PFN_vkDestroyDescriptorPool fp_vkDestroyDescriptorPool = nullptr; - PFN_vkResetDescriptorPool fp_vkResetDescriptorPool = nullptr; - PFN_vkAllocateDescriptorSets fp_vkAllocateDescriptorSets = nullptr; - PFN_vkFreeDescriptorSets fp_vkFreeDescriptorSets = nullptr; - PFN_vkUpdateDescriptorSets fp_vkUpdateDescriptorSets = nullptr; - PFN_vkCreateFramebuffer fp_vkCreateFramebuffer = nullptr; - PFN_vkDestroyFramebuffer fp_vkDestroyFramebuffer = nullptr; - PFN_vkCreateRenderPass fp_vkCreateRenderPass = nullptr; - PFN_vkDestroyRenderPass fp_vkDestroyRenderPass = nullptr; - PFN_vkGetRenderAreaGranularity fp_vkGetRenderAreaGranularity = nullptr; + PFN_vkCreateDescriptorPool fp_vkCreateDescriptorPool = nullptr; + PFN_vkDestroyDescriptorPool fp_vkDestroyDescriptorPool = nullptr; + PFN_vkResetDescriptorPool fp_vkResetDescriptorPool = nullptr; + PFN_vkAllocateDescriptorSets fp_vkAllocateDescriptorSets = nullptr; + PFN_vkFreeDescriptorSets fp_vkFreeDescriptorSets = nullptr; + PFN_vkUpdateDescriptorSets fp_vkUpdateDescriptorSets = nullptr; + PFN_vkCreateFramebuffer fp_vkCreateFramebuffer = nullptr; + PFN_vkDestroyFramebuffer fp_vkDestroyFramebuffer = nullptr; + PFN_vkCreateRenderPass fp_vkCreateRenderPass = nullptr; + PFN_vkDestroyRenderPass fp_vkDestroyRenderPass = nullptr; + PFN_vkGetRenderAreaGranularity fp_vkGetRenderAreaGranularity = nullptr; #if (defined(VK_KHR_maintenance5)) PFN_vkGetRenderingAreaGranularityKHR fp_vkGetRenderingAreaGranularityKHR = nullptr; #else - void * fp_vkGetRenderingAreaGranularityKHR{}; + void* fp_vkGetRenderingAreaGranularityKHR{}; #endif - PFN_vkCreateCommandPool fp_vkCreateCommandPool = nullptr; - PFN_vkDestroyCommandPool fp_vkDestroyCommandPool = nullptr; - PFN_vkResetCommandPool fp_vkResetCommandPool = nullptr; + PFN_vkCreateCommandPool fp_vkCreateCommandPool = nullptr; + PFN_vkDestroyCommandPool fp_vkDestroyCommandPool = nullptr; + PFN_vkResetCommandPool fp_vkResetCommandPool = nullptr; PFN_vkAllocateCommandBuffers fp_vkAllocateCommandBuffers = nullptr; - PFN_vkFreeCommandBuffers fp_vkFreeCommandBuffers = nullptr; - PFN_vkBeginCommandBuffer fp_vkBeginCommandBuffer = nullptr; - PFN_vkEndCommandBuffer fp_vkEndCommandBuffer = nullptr; - PFN_vkResetCommandBuffer fp_vkResetCommandBuffer = nullptr; - PFN_vkCmdBindPipeline fp_vkCmdBindPipeline = nullptr; + PFN_vkFreeCommandBuffers fp_vkFreeCommandBuffers = nullptr; + PFN_vkBeginCommandBuffer fp_vkBeginCommandBuffer = nullptr; + PFN_vkEndCommandBuffer fp_vkEndCommandBuffer = nullptr; + PFN_vkResetCommandBuffer fp_vkResetCommandBuffer = nullptr; + PFN_vkCmdBindPipeline fp_vkCmdBindPipeline = nullptr; #if (defined(VK_EXT_attachment_feedback_loop_dynamic_state)) PFN_vkCmdSetAttachmentFeedbackLoopEnableEXT fp_vkCmdSetAttachmentFeedbackLoopEnableEXT = nullptr; #else - void * fp_vkCmdSetAttachmentFeedbackLoopEnableEXT{}; + void* fp_vkCmdSetAttachmentFeedbackLoopEnableEXT{}; #endif - PFN_vkCmdSetViewport fp_vkCmdSetViewport = nullptr; - PFN_vkCmdSetScissor fp_vkCmdSetScissor = nullptr; - PFN_vkCmdSetLineWidth fp_vkCmdSetLineWidth = nullptr; - PFN_vkCmdSetDepthBias fp_vkCmdSetDepthBias = nullptr; - PFN_vkCmdSetBlendConstants fp_vkCmdSetBlendConstants = nullptr; - PFN_vkCmdSetDepthBounds fp_vkCmdSetDepthBounds = nullptr; + PFN_vkCmdSetViewport fp_vkCmdSetViewport = nullptr; + PFN_vkCmdSetScissor fp_vkCmdSetScissor = nullptr; + PFN_vkCmdSetLineWidth fp_vkCmdSetLineWidth = nullptr; + PFN_vkCmdSetDepthBias fp_vkCmdSetDepthBias = nullptr; + PFN_vkCmdSetBlendConstants fp_vkCmdSetBlendConstants = nullptr; + PFN_vkCmdSetDepthBounds fp_vkCmdSetDepthBounds = nullptr; PFN_vkCmdSetStencilCompareMask fp_vkCmdSetStencilCompareMask = nullptr; - PFN_vkCmdSetStencilWriteMask fp_vkCmdSetStencilWriteMask = nullptr; - PFN_vkCmdSetStencilReference fp_vkCmdSetStencilReference = nullptr; - PFN_vkCmdBindDescriptorSets fp_vkCmdBindDescriptorSets = nullptr; - PFN_vkCmdBindIndexBuffer fp_vkCmdBindIndexBuffer = nullptr; - PFN_vkCmdBindVertexBuffers fp_vkCmdBindVertexBuffers = nullptr; - PFN_vkCmdDraw fp_vkCmdDraw = nullptr; - PFN_vkCmdDrawIndexed fp_vkCmdDrawIndexed = nullptr; + PFN_vkCmdSetStencilWriteMask fp_vkCmdSetStencilWriteMask = nullptr; + PFN_vkCmdSetStencilReference fp_vkCmdSetStencilReference = nullptr; + PFN_vkCmdBindDescriptorSets fp_vkCmdBindDescriptorSets = nullptr; + PFN_vkCmdBindIndexBuffer fp_vkCmdBindIndexBuffer = nullptr; + PFN_vkCmdBindVertexBuffers fp_vkCmdBindVertexBuffers = nullptr; + PFN_vkCmdDraw fp_vkCmdDraw = nullptr; + PFN_vkCmdDrawIndexed fp_vkCmdDrawIndexed = nullptr; #if (defined(VK_EXT_multi_draw)) PFN_vkCmdDrawMultiEXT fp_vkCmdDrawMultiEXT = nullptr; #else - void * fp_vkCmdDrawMultiEXT{}; + void* fp_vkCmdDrawMultiEXT{}; #endif #if (defined(VK_EXT_multi_draw)) PFN_vkCmdDrawMultiIndexedEXT fp_vkCmdDrawMultiIndexedEXT = nullptr; #else - void * fp_vkCmdDrawMultiIndexedEXT{}; + void* fp_vkCmdDrawMultiIndexedEXT{}; #endif - PFN_vkCmdDrawIndirect fp_vkCmdDrawIndirect = nullptr; + PFN_vkCmdDrawIndirect fp_vkCmdDrawIndirect = nullptr; PFN_vkCmdDrawIndexedIndirect fp_vkCmdDrawIndexedIndirect = nullptr; - PFN_vkCmdDispatch fp_vkCmdDispatch = nullptr; - PFN_vkCmdDispatchIndirect fp_vkCmdDispatchIndirect = nullptr; + PFN_vkCmdDispatch fp_vkCmdDispatch = nullptr; + PFN_vkCmdDispatchIndirect fp_vkCmdDispatchIndirect = nullptr; #if (defined(VK_HUAWEI_subpass_shading)) PFN_vkCmdSubpassShadingHUAWEI fp_vkCmdSubpassShadingHUAWEI = nullptr; #else - void * fp_vkCmdSubpassShadingHUAWEI{}; + void* fp_vkCmdSubpassShadingHUAWEI{}; #endif #if (defined(VK_HUAWEI_cluster_culling_shader)) PFN_vkCmdDrawClusterHUAWEI fp_vkCmdDrawClusterHUAWEI = nullptr; #else - void * fp_vkCmdDrawClusterHUAWEI{}; + void* fp_vkCmdDrawClusterHUAWEI{}; #endif #if (defined(VK_HUAWEI_cluster_culling_shader)) PFN_vkCmdDrawClusterIndirectHUAWEI fp_vkCmdDrawClusterIndirectHUAWEI = nullptr; #else - void * fp_vkCmdDrawClusterIndirectHUAWEI{}; + void* fp_vkCmdDrawClusterIndirectHUAWEI{}; #endif #if (defined(VK_NV_device_generated_commands_compute)) PFN_vkCmdUpdatePipelineIndirectBufferNV fp_vkCmdUpdatePipelineIndirectBufferNV = nullptr; #else - void * fp_vkCmdUpdatePipelineIndirectBufferNV{}; + void* fp_vkCmdUpdatePipelineIndirectBufferNV{}; #endif - PFN_vkCmdCopyBuffer fp_vkCmdCopyBuffer = nullptr; - PFN_vkCmdCopyImage fp_vkCmdCopyImage = nullptr; - PFN_vkCmdBlitImage fp_vkCmdBlitImage = nullptr; + PFN_vkCmdCopyBuffer fp_vkCmdCopyBuffer = nullptr; + PFN_vkCmdCopyImage fp_vkCmdCopyImage = nullptr; + PFN_vkCmdBlitImage fp_vkCmdBlitImage = nullptr; PFN_vkCmdCopyBufferToImage fp_vkCmdCopyBufferToImage = nullptr; PFN_vkCmdCopyImageToBuffer fp_vkCmdCopyImageToBuffer = nullptr; #if (defined(VK_NV_copy_memory_indirect)) PFN_vkCmdCopyMemoryIndirectNV fp_vkCmdCopyMemoryIndirectNV = nullptr; #else - void * fp_vkCmdCopyMemoryIndirectNV{}; + void* fp_vkCmdCopyMemoryIndirectNV{}; #endif #if (defined(VK_NV_copy_memory_indirect)) PFN_vkCmdCopyMemoryToImageIndirectNV fp_vkCmdCopyMemoryToImageIndirectNV = nullptr; #else - void * fp_vkCmdCopyMemoryToImageIndirectNV{}; + void* fp_vkCmdCopyMemoryToImageIndirectNV{}; #endif - PFN_vkCmdUpdateBuffer fp_vkCmdUpdateBuffer = nullptr; - PFN_vkCmdFillBuffer fp_vkCmdFillBuffer = nullptr; - PFN_vkCmdClearColorImage fp_vkCmdClearColorImage = nullptr; + PFN_vkCmdUpdateBuffer fp_vkCmdUpdateBuffer = nullptr; + PFN_vkCmdFillBuffer fp_vkCmdFillBuffer = nullptr; + PFN_vkCmdClearColorImage fp_vkCmdClearColorImage = nullptr; PFN_vkCmdClearDepthStencilImage fp_vkCmdClearDepthStencilImage = nullptr; - PFN_vkCmdClearAttachments fp_vkCmdClearAttachments = nullptr; - PFN_vkCmdResolveImage fp_vkCmdResolveImage = nullptr; - PFN_vkCmdSetEvent fp_vkCmdSetEvent = nullptr; - PFN_vkCmdResetEvent fp_vkCmdResetEvent = nullptr; - PFN_vkCmdWaitEvents fp_vkCmdWaitEvents = nullptr; - PFN_vkCmdPipelineBarrier fp_vkCmdPipelineBarrier = nullptr; - PFN_vkCmdBeginQuery fp_vkCmdBeginQuery = nullptr; - PFN_vkCmdEndQuery fp_vkCmdEndQuery = nullptr; + PFN_vkCmdClearAttachments fp_vkCmdClearAttachments = nullptr; + PFN_vkCmdResolveImage fp_vkCmdResolveImage = nullptr; + PFN_vkCmdSetEvent fp_vkCmdSetEvent = nullptr; + PFN_vkCmdResetEvent fp_vkCmdResetEvent = nullptr; + PFN_vkCmdWaitEvents fp_vkCmdWaitEvents = nullptr; + PFN_vkCmdPipelineBarrier fp_vkCmdPipelineBarrier = nullptr; + PFN_vkCmdBeginQuery fp_vkCmdBeginQuery = nullptr; + PFN_vkCmdEndQuery fp_vkCmdEndQuery = nullptr; #if (defined(VK_EXT_conditional_rendering)) PFN_vkCmdBeginConditionalRenderingEXT fp_vkCmdBeginConditionalRenderingEXT = nullptr; #else - void * fp_vkCmdBeginConditionalRenderingEXT{}; + void* fp_vkCmdBeginConditionalRenderingEXT{}; #endif #if (defined(VK_EXT_conditional_rendering)) PFN_vkCmdEndConditionalRenderingEXT fp_vkCmdEndConditionalRenderingEXT = nullptr; #else - void * fp_vkCmdEndConditionalRenderingEXT{}; + void* fp_vkCmdEndConditionalRenderingEXT{}; #endif - PFN_vkCmdResetQueryPool fp_vkCmdResetQueryPool = nullptr; - PFN_vkCmdWriteTimestamp fp_vkCmdWriteTimestamp = nullptr; + PFN_vkCmdResetQueryPool fp_vkCmdResetQueryPool = nullptr; + PFN_vkCmdWriteTimestamp fp_vkCmdWriteTimestamp = nullptr; PFN_vkCmdCopyQueryPoolResults fp_vkCmdCopyQueryPoolResults = nullptr; - PFN_vkCmdPushConstants fp_vkCmdPushConstants = nullptr; - PFN_vkCmdBeginRenderPass fp_vkCmdBeginRenderPass = nullptr; - PFN_vkCmdNextSubpass fp_vkCmdNextSubpass = nullptr; - PFN_vkCmdEndRenderPass fp_vkCmdEndRenderPass = nullptr; - PFN_vkCmdExecuteCommands fp_vkCmdExecuteCommands = nullptr; + PFN_vkCmdPushConstants fp_vkCmdPushConstants = nullptr; + PFN_vkCmdBeginRenderPass fp_vkCmdBeginRenderPass = nullptr; + PFN_vkCmdNextSubpass fp_vkCmdNextSubpass = nullptr; + PFN_vkCmdEndRenderPass fp_vkCmdEndRenderPass = nullptr; + PFN_vkCmdExecuteCommands fp_vkCmdExecuteCommands = nullptr; #if (defined(VK_KHR_display_swapchain)) PFN_vkCreateSharedSwapchainsKHR fp_vkCreateSharedSwapchainsKHR = nullptr; #else - void * fp_vkCreateSharedSwapchainsKHR{}; + void* fp_vkCreateSharedSwapchainsKHR{}; #endif #if (defined(VK_KHR_swapchain)) PFN_vkCreateSwapchainKHR fp_vkCreateSwapchainKHR = nullptr; #else - void * fp_vkCreateSwapchainKHR{}; + void* fp_vkCreateSwapchainKHR{}; #endif #if (defined(VK_KHR_swapchain)) PFN_vkDestroySwapchainKHR fp_vkDestroySwapchainKHR = nullptr; #else - void * fp_vkDestroySwapchainKHR{}; + void* fp_vkDestroySwapchainKHR{}; #endif #if (defined(VK_KHR_swapchain)) PFN_vkGetSwapchainImagesKHR fp_vkGetSwapchainImagesKHR = nullptr; #else - void * fp_vkGetSwapchainImagesKHR{}; + void* fp_vkGetSwapchainImagesKHR{}; #endif #if (defined(VK_KHR_swapchain)) PFN_vkAcquireNextImageKHR fp_vkAcquireNextImageKHR = nullptr; #else - void * fp_vkAcquireNextImageKHR{}; + void* fp_vkAcquireNextImageKHR{}; #endif #if (defined(VK_KHR_swapchain)) PFN_vkQueuePresentKHR fp_vkQueuePresentKHR = nullptr; #else - void * fp_vkQueuePresentKHR{}; + void* fp_vkQueuePresentKHR{}; #endif #if (defined(VK_EXT_debug_marker)) PFN_vkDebugMarkerSetObjectNameEXT fp_vkDebugMarkerSetObjectNameEXT = nullptr; #else - void * fp_vkDebugMarkerSetObjectNameEXT{}; + void* fp_vkDebugMarkerSetObjectNameEXT{}; #endif #if (defined(VK_EXT_debug_marker)) PFN_vkDebugMarkerSetObjectTagEXT fp_vkDebugMarkerSetObjectTagEXT = nullptr; #else - void * fp_vkDebugMarkerSetObjectTagEXT{}; + void* fp_vkDebugMarkerSetObjectTagEXT{}; #endif #if (defined(VK_EXT_debug_marker)) PFN_vkCmdDebugMarkerBeginEXT fp_vkCmdDebugMarkerBeginEXT = nullptr; #else - void * fp_vkCmdDebugMarkerBeginEXT{}; + void* fp_vkCmdDebugMarkerBeginEXT{}; #endif #if (defined(VK_EXT_debug_marker)) PFN_vkCmdDebugMarkerEndEXT fp_vkCmdDebugMarkerEndEXT = nullptr; #else - void * fp_vkCmdDebugMarkerEndEXT{}; + void* fp_vkCmdDebugMarkerEndEXT{}; #endif #if (defined(VK_EXT_debug_marker)) PFN_vkCmdDebugMarkerInsertEXT fp_vkCmdDebugMarkerInsertEXT = nullptr; #else - void * fp_vkCmdDebugMarkerInsertEXT{}; + void* fp_vkCmdDebugMarkerInsertEXT{}; #endif #if (defined(VK_NV_external_memory_win32)) PFN_vkGetMemoryWin32HandleNV fp_vkGetMemoryWin32HandleNV = nullptr; #else - void * fp_vkGetMemoryWin32HandleNV{}; + void* fp_vkGetMemoryWin32HandleNV{}; #endif #if (defined(VK_NV_device_generated_commands)) PFN_vkCmdExecuteGeneratedCommandsNV fp_vkCmdExecuteGeneratedCommandsNV = nullptr; #else - void * fp_vkCmdExecuteGeneratedCommandsNV{}; + void* fp_vkCmdExecuteGeneratedCommandsNV{}; #endif #if (defined(VK_NV_device_generated_commands)) PFN_vkCmdPreprocessGeneratedCommandsNV fp_vkCmdPreprocessGeneratedCommandsNV = nullptr; #else - void * fp_vkCmdPreprocessGeneratedCommandsNV{}; + void* fp_vkCmdPreprocessGeneratedCommandsNV{}; #endif #if (defined(VK_NV_device_generated_commands)) PFN_vkCmdBindPipelineShaderGroupNV fp_vkCmdBindPipelineShaderGroupNV = nullptr; #else - void * fp_vkCmdBindPipelineShaderGroupNV{}; + void* fp_vkCmdBindPipelineShaderGroupNV{}; #endif #if (defined(VK_NV_device_generated_commands)) PFN_vkGetGeneratedCommandsMemoryRequirementsNV fp_vkGetGeneratedCommandsMemoryRequirementsNV = nullptr; #else - void * fp_vkGetGeneratedCommandsMemoryRequirementsNV{}; + void* fp_vkGetGeneratedCommandsMemoryRequirementsNV{}; #endif #if (defined(VK_NV_device_generated_commands)) PFN_vkCreateIndirectCommandsLayoutNV fp_vkCreateIndirectCommandsLayoutNV = nullptr; #else - void * fp_vkCreateIndirectCommandsLayoutNV{}; + void* fp_vkCreateIndirectCommandsLayoutNV{}; #endif #if (defined(VK_NV_device_generated_commands)) PFN_vkDestroyIndirectCommandsLayoutNV fp_vkDestroyIndirectCommandsLayoutNV = nullptr; #else - void * fp_vkDestroyIndirectCommandsLayoutNV{}; + void* fp_vkDestroyIndirectCommandsLayoutNV{}; #endif #if (defined(VK_EXT_device_generated_commands)) PFN_vkCmdExecuteGeneratedCommandsEXT fp_vkCmdExecuteGeneratedCommandsEXT = nullptr; #else - void * fp_vkCmdExecuteGeneratedCommandsEXT{}; + void* fp_vkCmdExecuteGeneratedCommandsEXT{}; #endif #if (defined(VK_EXT_device_generated_commands)) PFN_vkCmdPreprocessGeneratedCommandsEXT fp_vkCmdPreprocessGeneratedCommandsEXT = nullptr; #else - void * fp_vkCmdPreprocessGeneratedCommandsEXT{}; + void* fp_vkCmdPreprocessGeneratedCommandsEXT{}; #endif #if (defined(VK_EXT_device_generated_commands)) PFN_vkGetGeneratedCommandsMemoryRequirementsEXT fp_vkGetGeneratedCommandsMemoryRequirementsEXT = nullptr; #else - void * fp_vkGetGeneratedCommandsMemoryRequirementsEXT{}; + void* fp_vkGetGeneratedCommandsMemoryRequirementsEXT{}; #endif #if (defined(VK_EXT_device_generated_commands)) PFN_vkCreateIndirectCommandsLayoutEXT fp_vkCreateIndirectCommandsLayoutEXT = nullptr; #else - void * fp_vkCreateIndirectCommandsLayoutEXT{}; + void* fp_vkCreateIndirectCommandsLayoutEXT{}; #endif #if (defined(VK_EXT_device_generated_commands)) PFN_vkDestroyIndirectCommandsLayoutEXT fp_vkDestroyIndirectCommandsLayoutEXT = nullptr; #else - void * fp_vkDestroyIndirectCommandsLayoutEXT{}; + void* fp_vkDestroyIndirectCommandsLayoutEXT{}; #endif #if (defined(VK_EXT_device_generated_commands)) PFN_vkCreateIndirectExecutionSetEXT fp_vkCreateIndirectExecutionSetEXT = nullptr; #else - void * fp_vkCreateIndirectExecutionSetEXT{}; + void* fp_vkCreateIndirectExecutionSetEXT{}; #endif #if (defined(VK_EXT_device_generated_commands)) PFN_vkDestroyIndirectExecutionSetEXT fp_vkDestroyIndirectExecutionSetEXT = nullptr; #else - void * fp_vkDestroyIndirectExecutionSetEXT{}; + void* fp_vkDestroyIndirectExecutionSetEXT{}; #endif #if (defined(VK_EXT_device_generated_commands)) PFN_vkUpdateIndirectExecutionSetPipelineEXT fp_vkUpdateIndirectExecutionSetPipelineEXT = nullptr; #else - void * fp_vkUpdateIndirectExecutionSetPipelineEXT{}; + void* fp_vkUpdateIndirectExecutionSetPipelineEXT{}; #endif #if (defined(VK_EXT_device_generated_commands)) PFN_vkUpdateIndirectExecutionSetShaderEXT fp_vkUpdateIndirectExecutionSetShaderEXT = nullptr; #else - void * fp_vkUpdateIndirectExecutionSetShaderEXT{}; + void* fp_vkUpdateIndirectExecutionSetShaderEXT{}; #endif #if (defined(VK_KHR_push_descriptor)) PFN_vkCmdPushDescriptorSetKHR fp_vkCmdPushDescriptorSetKHR = nullptr; #else - void * fp_vkCmdPushDescriptorSetKHR{}; + void* fp_vkCmdPushDescriptorSetKHR{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkTrimCommandPool fp_vkTrimCommandPool = nullptr; #else - void * fp_vkTrimCommandPool{}; + void* fp_vkTrimCommandPool{}; #endif #if (defined(VK_KHR_external_memory_win32)) PFN_vkGetMemoryWin32HandleKHR fp_vkGetMemoryWin32HandleKHR = nullptr; #else - void * fp_vkGetMemoryWin32HandleKHR{}; + void* fp_vkGetMemoryWin32HandleKHR{}; #endif #if (defined(VK_KHR_external_memory_win32)) PFN_vkGetMemoryWin32HandlePropertiesKHR fp_vkGetMemoryWin32HandlePropertiesKHR = nullptr; #else - void * fp_vkGetMemoryWin32HandlePropertiesKHR{}; + void* fp_vkGetMemoryWin32HandlePropertiesKHR{}; #endif #if (defined(VK_KHR_external_memory_fd)) PFN_vkGetMemoryFdKHR fp_vkGetMemoryFdKHR = nullptr; #else - void * fp_vkGetMemoryFdKHR{}; + void* fp_vkGetMemoryFdKHR{}; #endif #if (defined(VK_KHR_external_memory_fd)) PFN_vkGetMemoryFdPropertiesKHR fp_vkGetMemoryFdPropertiesKHR = nullptr; #else - void * fp_vkGetMemoryFdPropertiesKHR{}; + void* fp_vkGetMemoryFdPropertiesKHR{}; #endif #if (defined(VK_FUCHSIA_external_memory)) PFN_vkGetMemoryZirconHandleFUCHSIA fp_vkGetMemoryZirconHandleFUCHSIA = nullptr; #else - void * fp_vkGetMemoryZirconHandleFUCHSIA{}; + void* fp_vkGetMemoryZirconHandleFUCHSIA{}; #endif #if (defined(VK_FUCHSIA_external_memory)) PFN_vkGetMemoryZirconHandlePropertiesFUCHSIA fp_vkGetMemoryZirconHandlePropertiesFUCHSIA = nullptr; #else - void * fp_vkGetMemoryZirconHandlePropertiesFUCHSIA{}; + void* fp_vkGetMemoryZirconHandlePropertiesFUCHSIA{}; #endif #if (defined(VK_NV_external_memory_rdma)) PFN_vkGetMemoryRemoteAddressNV fp_vkGetMemoryRemoteAddressNV = nullptr; #else - void * fp_vkGetMemoryRemoteAddressNV{}; + void* fp_vkGetMemoryRemoteAddressNV{}; #endif #if (defined(VK_NV_external_memory_sci_buf)) PFN_vkGetMemorySciBufNV fp_vkGetMemorySciBufNV = nullptr; #else - void * fp_vkGetMemorySciBufNV{}; + void* fp_vkGetMemorySciBufNV{}; #endif #if (defined(VK_KHR_external_semaphore_win32)) PFN_vkGetSemaphoreWin32HandleKHR fp_vkGetSemaphoreWin32HandleKHR = nullptr; #else - void * fp_vkGetSemaphoreWin32HandleKHR{}; + void* fp_vkGetSemaphoreWin32HandleKHR{}; #endif #if (defined(VK_KHR_external_semaphore_win32)) PFN_vkImportSemaphoreWin32HandleKHR fp_vkImportSemaphoreWin32HandleKHR = nullptr; #else - void * fp_vkImportSemaphoreWin32HandleKHR{}; + void* fp_vkImportSemaphoreWin32HandleKHR{}; #endif #if (defined(VK_KHR_external_semaphore_fd)) PFN_vkGetSemaphoreFdKHR fp_vkGetSemaphoreFdKHR = nullptr; #else - void * fp_vkGetSemaphoreFdKHR{}; + void* fp_vkGetSemaphoreFdKHR{}; #endif #if (defined(VK_KHR_external_semaphore_fd)) PFN_vkImportSemaphoreFdKHR fp_vkImportSemaphoreFdKHR = nullptr; #else - void * fp_vkImportSemaphoreFdKHR{}; + void* fp_vkImportSemaphoreFdKHR{}; #endif #if (defined(VK_FUCHSIA_external_semaphore)) PFN_vkGetSemaphoreZirconHandleFUCHSIA fp_vkGetSemaphoreZirconHandleFUCHSIA = nullptr; #else - void * fp_vkGetSemaphoreZirconHandleFUCHSIA{}; + void* fp_vkGetSemaphoreZirconHandleFUCHSIA{}; #endif #if (defined(VK_FUCHSIA_external_semaphore)) PFN_vkImportSemaphoreZirconHandleFUCHSIA fp_vkImportSemaphoreZirconHandleFUCHSIA = nullptr; #else - void * fp_vkImportSemaphoreZirconHandleFUCHSIA{}; + void* fp_vkImportSemaphoreZirconHandleFUCHSIA{}; #endif #if (defined(VK_KHR_external_fence_win32)) PFN_vkGetFenceWin32HandleKHR fp_vkGetFenceWin32HandleKHR = nullptr; #else - void * fp_vkGetFenceWin32HandleKHR{}; + void* fp_vkGetFenceWin32HandleKHR{}; #endif #if (defined(VK_KHR_external_fence_win32)) PFN_vkImportFenceWin32HandleKHR fp_vkImportFenceWin32HandleKHR = nullptr; #else - void * fp_vkImportFenceWin32HandleKHR{}; + void* fp_vkImportFenceWin32HandleKHR{}; #endif #if (defined(VK_KHR_external_fence_fd)) PFN_vkGetFenceFdKHR fp_vkGetFenceFdKHR = nullptr; #else - void * fp_vkGetFenceFdKHR{}; + void* fp_vkGetFenceFdKHR{}; #endif #if (defined(VK_KHR_external_fence_fd)) PFN_vkImportFenceFdKHR fp_vkImportFenceFdKHR = nullptr; #else - void * fp_vkImportFenceFdKHR{}; + void* fp_vkImportFenceFdKHR{}; #endif #if (defined(VK_NV_external_sci_sync)) || (defined(VK_NV_external_sci_sync2)) PFN_vkGetFenceSciSyncFenceNV fp_vkGetFenceSciSyncFenceNV = nullptr; #else - void * fp_vkGetFenceSciSyncFenceNV{}; + void* fp_vkGetFenceSciSyncFenceNV{}; #endif #if (defined(VK_NV_external_sci_sync)) || (defined(VK_NV_external_sci_sync2)) PFN_vkGetFenceSciSyncObjNV fp_vkGetFenceSciSyncObjNV = nullptr; #else - void * fp_vkGetFenceSciSyncObjNV{}; + void* fp_vkGetFenceSciSyncObjNV{}; #endif #if (defined(VK_NV_external_sci_sync)) || (defined(VK_NV_external_sci_sync2)) PFN_vkImportFenceSciSyncFenceNV fp_vkImportFenceSciSyncFenceNV = nullptr; #else - void * fp_vkImportFenceSciSyncFenceNV{}; + void* fp_vkImportFenceSciSyncFenceNV{}; #endif #if (defined(VK_NV_external_sci_sync)) || (defined(VK_NV_external_sci_sync2)) PFN_vkImportFenceSciSyncObjNV fp_vkImportFenceSciSyncObjNV = nullptr; #else - void * fp_vkImportFenceSciSyncObjNV{}; + void* fp_vkImportFenceSciSyncObjNV{}; #endif #if (defined(VK_NV_external_sci_sync)) PFN_vkGetSemaphoreSciSyncObjNV fp_vkGetSemaphoreSciSyncObjNV = nullptr; #else - void * fp_vkGetSemaphoreSciSyncObjNV{}; + void* fp_vkGetSemaphoreSciSyncObjNV{}; #endif #if (defined(VK_NV_external_sci_sync)) PFN_vkImportSemaphoreSciSyncObjNV fp_vkImportSemaphoreSciSyncObjNV = nullptr; #else - void * fp_vkImportSemaphoreSciSyncObjNV{}; + void* fp_vkImportSemaphoreSciSyncObjNV{}; #endif #if (defined(VK_NV_external_sci_sync2)) PFN_vkCreateSemaphoreSciSyncPoolNV fp_vkCreateSemaphoreSciSyncPoolNV = nullptr; #else - void * fp_vkCreateSemaphoreSciSyncPoolNV{}; + void* fp_vkCreateSemaphoreSciSyncPoolNV{}; #endif #if (defined(VK_NV_external_sci_sync2)) PFN_vkDestroySemaphoreSciSyncPoolNV fp_vkDestroySemaphoreSciSyncPoolNV = nullptr; #else - void * fp_vkDestroySemaphoreSciSyncPoolNV{}; + void* fp_vkDestroySemaphoreSciSyncPoolNV{}; #endif #if (defined(VK_EXT_display_control)) PFN_vkDisplayPowerControlEXT fp_vkDisplayPowerControlEXT = nullptr; #else - void * fp_vkDisplayPowerControlEXT{}; + void* fp_vkDisplayPowerControlEXT{}; #endif #if (defined(VK_EXT_display_control)) PFN_vkRegisterDeviceEventEXT fp_vkRegisterDeviceEventEXT = nullptr; #else - void * fp_vkRegisterDeviceEventEXT{}; + void* fp_vkRegisterDeviceEventEXT{}; #endif #if (defined(VK_EXT_display_control)) PFN_vkRegisterDisplayEventEXT fp_vkRegisterDisplayEventEXT = nullptr; #else - void * fp_vkRegisterDisplayEventEXT{}; + void* fp_vkRegisterDisplayEventEXT{}; #endif #if (defined(VK_EXT_display_control)) PFN_vkGetSwapchainCounterEXT fp_vkGetSwapchainCounterEXT = nullptr; #else - void * fp_vkGetSwapchainCounterEXT{}; + void* fp_vkGetSwapchainCounterEXT{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkGetDeviceGroupPeerMemoryFeatures fp_vkGetDeviceGroupPeerMemoryFeatures = nullptr; #else - void * fp_vkGetDeviceGroupPeerMemoryFeatures{}; + void* fp_vkGetDeviceGroupPeerMemoryFeatures{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkBindBufferMemory2 fp_vkBindBufferMemory2 = nullptr; #else - void * fp_vkBindBufferMemory2{}; + void* fp_vkBindBufferMemory2{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkBindImageMemory2 fp_vkBindImageMemory2 = nullptr; #else - void * fp_vkBindImageMemory2{}; + void* fp_vkBindImageMemory2{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkCmdSetDeviceMask fp_vkCmdSetDeviceMask = nullptr; #else - void * fp_vkCmdSetDeviceMask{}; + void* fp_vkCmdSetDeviceMask{}; #endif #if (defined(VK_KHR_swapchain)) || (defined(VK_KHR_device_group)) PFN_vkGetDeviceGroupPresentCapabilitiesKHR fp_vkGetDeviceGroupPresentCapabilitiesKHR = nullptr; #else - void * fp_vkGetDeviceGroupPresentCapabilitiesKHR{}; + void* fp_vkGetDeviceGroupPresentCapabilitiesKHR{}; #endif #if (defined(VK_KHR_swapchain)) || (defined(VK_KHR_device_group)) PFN_vkGetDeviceGroupSurfacePresentModesKHR fp_vkGetDeviceGroupSurfacePresentModesKHR = nullptr; #else - void * fp_vkGetDeviceGroupSurfacePresentModesKHR{}; + void* fp_vkGetDeviceGroupSurfacePresentModesKHR{}; #endif #if (defined(VK_KHR_swapchain)) || (defined(VK_KHR_device_group)) PFN_vkAcquireNextImage2KHR fp_vkAcquireNextImage2KHR = nullptr; #else - void * fp_vkAcquireNextImage2KHR{}; + void* fp_vkAcquireNextImage2KHR{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkCmdDispatchBase fp_vkCmdDispatchBase = nullptr; #else - void * fp_vkCmdDispatchBase{}; + void* fp_vkCmdDispatchBase{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkCreateDescriptorUpdateTemplate fp_vkCreateDescriptorUpdateTemplate = nullptr; #else - void * fp_vkCreateDescriptorUpdateTemplate{}; + void* fp_vkCreateDescriptorUpdateTemplate{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkDestroyDescriptorUpdateTemplate fp_vkDestroyDescriptorUpdateTemplate = nullptr; #else - void * fp_vkDestroyDescriptorUpdateTemplate{}; + void* fp_vkDestroyDescriptorUpdateTemplate{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkUpdateDescriptorSetWithTemplate fp_vkUpdateDescriptorSetWithTemplate = nullptr; #else - void * fp_vkUpdateDescriptorSetWithTemplate{}; + void* fp_vkUpdateDescriptorSetWithTemplate{}; #endif #if (defined(VK_KHR_push_descriptor)) || (defined(VK_KHR_descriptor_update_template)) PFN_vkCmdPushDescriptorSetWithTemplateKHR fp_vkCmdPushDescriptorSetWithTemplateKHR = nullptr; #else - void * fp_vkCmdPushDescriptorSetWithTemplateKHR{}; + void* fp_vkCmdPushDescriptorSetWithTemplateKHR{}; #endif #if (defined(VK_EXT_hdr_metadata)) PFN_vkSetHdrMetadataEXT fp_vkSetHdrMetadataEXT = nullptr; #else - void * fp_vkSetHdrMetadataEXT{}; + void* fp_vkSetHdrMetadataEXT{}; #endif #if (defined(VK_KHR_shared_presentable_image)) PFN_vkGetSwapchainStatusKHR fp_vkGetSwapchainStatusKHR = nullptr; #else - void * fp_vkGetSwapchainStatusKHR{}; + void* fp_vkGetSwapchainStatusKHR{}; #endif #if (defined(VK_GOOGLE_display_timing)) PFN_vkGetRefreshCycleDurationGOOGLE fp_vkGetRefreshCycleDurationGOOGLE = nullptr; #else - void * fp_vkGetRefreshCycleDurationGOOGLE{}; + void* fp_vkGetRefreshCycleDurationGOOGLE{}; #endif #if (defined(VK_GOOGLE_display_timing)) PFN_vkGetPastPresentationTimingGOOGLE fp_vkGetPastPresentationTimingGOOGLE = nullptr; #else - void * fp_vkGetPastPresentationTimingGOOGLE{}; + void* fp_vkGetPastPresentationTimingGOOGLE{}; #endif #if (defined(VK_NV_clip_space_w_scaling)) PFN_vkCmdSetViewportWScalingNV fp_vkCmdSetViewportWScalingNV = nullptr; #else - void * fp_vkCmdSetViewportWScalingNV{}; + void* fp_vkCmdSetViewportWScalingNV{}; #endif #if (defined(VK_EXT_discard_rectangles)) PFN_vkCmdSetDiscardRectangleEXT fp_vkCmdSetDiscardRectangleEXT = nullptr; #else - void * fp_vkCmdSetDiscardRectangleEXT{}; + void* fp_vkCmdSetDiscardRectangleEXT{}; #endif #if ((defined(VK_EXT_discard_rectangles))) && VK_HEADER_VERSION >= 241 PFN_vkCmdSetDiscardRectangleEnableEXT fp_vkCmdSetDiscardRectangleEnableEXT = nullptr; #else - void * fp_vkCmdSetDiscardRectangleEnableEXT{}; + void* fp_vkCmdSetDiscardRectangleEnableEXT{}; #endif #if ((defined(VK_EXT_discard_rectangles))) && VK_HEADER_VERSION >= 241 PFN_vkCmdSetDiscardRectangleModeEXT fp_vkCmdSetDiscardRectangleModeEXT = nullptr; #else - void * fp_vkCmdSetDiscardRectangleModeEXT{}; + void* fp_vkCmdSetDiscardRectangleModeEXT{}; #endif #if (defined(VK_EXT_sample_locations)) PFN_vkCmdSetSampleLocationsEXT fp_vkCmdSetSampleLocationsEXT = nullptr; #else - void * fp_vkCmdSetSampleLocationsEXT{}; + void* fp_vkCmdSetSampleLocationsEXT{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkGetBufferMemoryRequirements2 fp_vkGetBufferMemoryRequirements2 = nullptr; #else - void * fp_vkGetBufferMemoryRequirements2{}; + void* fp_vkGetBufferMemoryRequirements2{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkGetImageMemoryRequirements2 fp_vkGetImageMemoryRequirements2 = nullptr; #else - void * fp_vkGetImageMemoryRequirements2{}; + void* fp_vkGetImageMemoryRequirements2{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkGetImageSparseMemoryRequirements2 fp_vkGetImageSparseMemoryRequirements2 = nullptr; #else - void * fp_vkGetImageSparseMemoryRequirements2{}; + void* fp_vkGetImageSparseMemoryRequirements2{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkGetDeviceBufferMemoryRequirements fp_vkGetDeviceBufferMemoryRequirements = nullptr; #else - void * fp_vkGetDeviceBufferMemoryRequirements{}; + void* fp_vkGetDeviceBufferMemoryRequirements{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkGetDeviceImageMemoryRequirements fp_vkGetDeviceImageMemoryRequirements = nullptr; #else - void * fp_vkGetDeviceImageMemoryRequirements{}; + void* fp_vkGetDeviceImageMemoryRequirements{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkGetDeviceImageSparseMemoryRequirements fp_vkGetDeviceImageSparseMemoryRequirements = nullptr; #else - void * fp_vkGetDeviceImageSparseMemoryRequirements{}; + void* fp_vkGetDeviceImageSparseMemoryRequirements{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkCreateSamplerYcbcrConversion fp_vkCreateSamplerYcbcrConversion = nullptr; #else - void * fp_vkCreateSamplerYcbcrConversion{}; + void* fp_vkCreateSamplerYcbcrConversion{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkDestroySamplerYcbcrConversion fp_vkDestroySamplerYcbcrConversion = nullptr; #else - void * fp_vkDestroySamplerYcbcrConversion{}; + void* fp_vkDestroySamplerYcbcrConversion{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkGetDeviceQueue2 fp_vkGetDeviceQueue2 = nullptr; #else - void * fp_vkGetDeviceQueue2{}; + void* fp_vkGetDeviceQueue2{}; #endif #if (defined(VK_EXT_validation_cache)) PFN_vkCreateValidationCacheEXT fp_vkCreateValidationCacheEXT = nullptr; #else - void * fp_vkCreateValidationCacheEXT{}; + void* fp_vkCreateValidationCacheEXT{}; #endif #if (defined(VK_EXT_validation_cache)) PFN_vkDestroyValidationCacheEXT fp_vkDestroyValidationCacheEXT = nullptr; #else - void * fp_vkDestroyValidationCacheEXT{}; + void* fp_vkDestroyValidationCacheEXT{}; #endif #if (defined(VK_EXT_validation_cache)) PFN_vkGetValidationCacheDataEXT fp_vkGetValidationCacheDataEXT = nullptr; #else - void * fp_vkGetValidationCacheDataEXT{}; + void* fp_vkGetValidationCacheDataEXT{}; #endif #if (defined(VK_EXT_validation_cache)) PFN_vkMergeValidationCachesEXT fp_vkMergeValidationCachesEXT = nullptr; #else - void * fp_vkMergeValidationCachesEXT{}; + void* fp_vkMergeValidationCachesEXT{}; #endif #if (defined(VK_VERSION_1_1)) PFN_vkGetDescriptorSetLayoutSupport fp_vkGetDescriptorSetLayoutSupport = nullptr; #else - void * fp_vkGetDescriptorSetLayoutSupport{}; + void* fp_vkGetDescriptorSetLayoutSupport{}; #endif #if (defined(VK_ANDROID_native_buffer)) PFN_vkGetSwapchainGrallocUsageANDROID fp_vkGetSwapchainGrallocUsageANDROID = nullptr; #else - void * fp_vkGetSwapchainGrallocUsageANDROID{}; + void* fp_vkGetSwapchainGrallocUsageANDROID{}; #endif #if (defined(VK_ANDROID_native_buffer)) PFN_vkGetSwapchainGrallocUsage2ANDROID fp_vkGetSwapchainGrallocUsage2ANDROID = nullptr; #else - void * fp_vkGetSwapchainGrallocUsage2ANDROID{}; + void* fp_vkGetSwapchainGrallocUsage2ANDROID{}; #endif #if (defined(VK_ANDROID_native_buffer)) PFN_vkAcquireImageANDROID fp_vkAcquireImageANDROID = nullptr; #else - void * fp_vkAcquireImageANDROID{}; + void* fp_vkAcquireImageANDROID{}; #endif #if (defined(VK_ANDROID_native_buffer)) PFN_vkQueueSignalReleaseImageANDROID fp_vkQueueSignalReleaseImageANDROID = nullptr; #else - void * fp_vkQueueSignalReleaseImageANDROID{}; + void* fp_vkQueueSignalReleaseImageANDROID{}; #endif #if (defined(VK_AMD_shader_info)) PFN_vkGetShaderInfoAMD fp_vkGetShaderInfoAMD = nullptr; #else - void * fp_vkGetShaderInfoAMD{}; + void* fp_vkGetShaderInfoAMD{}; #endif #if (defined(VK_AMD_display_native_hdr)) PFN_vkSetLocalDimmingAMD fp_vkSetLocalDimmingAMD = nullptr; #else - void * fp_vkSetLocalDimmingAMD{}; + void* fp_vkSetLocalDimmingAMD{}; #endif #if (defined(VK_KHR_calibrated_timestamps)) PFN_vkGetCalibratedTimestampsKHR fp_vkGetCalibratedTimestampsKHR = nullptr; #else - void * fp_vkGetCalibratedTimestampsKHR{}; + void* fp_vkGetCalibratedTimestampsKHR{}; #endif #if (defined(VK_EXT_debug_utils)) PFN_vkSetDebugUtilsObjectNameEXT fp_vkSetDebugUtilsObjectNameEXT = nullptr; #else - void * fp_vkSetDebugUtilsObjectNameEXT{}; + void* fp_vkSetDebugUtilsObjectNameEXT{}; #endif #if (defined(VK_EXT_debug_utils)) PFN_vkSetDebugUtilsObjectTagEXT fp_vkSetDebugUtilsObjectTagEXT = nullptr; #else - void * fp_vkSetDebugUtilsObjectTagEXT{}; + void* fp_vkSetDebugUtilsObjectTagEXT{}; #endif #if (defined(VK_EXT_debug_utils)) PFN_vkQueueBeginDebugUtilsLabelEXT fp_vkQueueBeginDebugUtilsLabelEXT = nullptr; #else - void * fp_vkQueueBeginDebugUtilsLabelEXT{}; + void* fp_vkQueueBeginDebugUtilsLabelEXT{}; #endif #if (defined(VK_EXT_debug_utils)) PFN_vkQueueEndDebugUtilsLabelEXT fp_vkQueueEndDebugUtilsLabelEXT = nullptr; #else - void * fp_vkQueueEndDebugUtilsLabelEXT{}; + void* fp_vkQueueEndDebugUtilsLabelEXT{}; #endif #if (defined(VK_EXT_debug_utils)) PFN_vkQueueInsertDebugUtilsLabelEXT fp_vkQueueInsertDebugUtilsLabelEXT = nullptr; #else - void * fp_vkQueueInsertDebugUtilsLabelEXT{}; + void* fp_vkQueueInsertDebugUtilsLabelEXT{}; #endif #if (defined(VK_EXT_debug_utils)) PFN_vkCmdBeginDebugUtilsLabelEXT fp_vkCmdBeginDebugUtilsLabelEXT = nullptr; #else - void * fp_vkCmdBeginDebugUtilsLabelEXT{}; + void* fp_vkCmdBeginDebugUtilsLabelEXT{}; #endif #if (defined(VK_EXT_debug_utils)) PFN_vkCmdEndDebugUtilsLabelEXT fp_vkCmdEndDebugUtilsLabelEXT = nullptr; #else - void * fp_vkCmdEndDebugUtilsLabelEXT{}; + void* fp_vkCmdEndDebugUtilsLabelEXT{}; #endif #if (defined(VK_EXT_debug_utils)) PFN_vkCmdInsertDebugUtilsLabelEXT fp_vkCmdInsertDebugUtilsLabelEXT = nullptr; #else - void * fp_vkCmdInsertDebugUtilsLabelEXT{}; + void* fp_vkCmdInsertDebugUtilsLabelEXT{}; #endif #if (defined(VK_EXT_external_memory_host)) PFN_vkGetMemoryHostPointerPropertiesEXT fp_vkGetMemoryHostPointerPropertiesEXT = nullptr; #else - void * fp_vkGetMemoryHostPointerPropertiesEXT{}; + void* fp_vkGetMemoryHostPointerPropertiesEXT{}; #endif #if (defined(VK_AMD_buffer_marker)) PFN_vkCmdWriteBufferMarkerAMD fp_vkCmdWriteBufferMarkerAMD = nullptr; #else - void * fp_vkCmdWriteBufferMarkerAMD{}; + void* fp_vkCmdWriteBufferMarkerAMD{}; #endif #if (defined(VK_VERSION_1_2)) PFN_vkCreateRenderPass2 fp_vkCreateRenderPass2 = nullptr; #else - void * fp_vkCreateRenderPass2{}; + void* fp_vkCreateRenderPass2{}; #endif #if (defined(VK_VERSION_1_2)) PFN_vkCmdBeginRenderPass2 fp_vkCmdBeginRenderPass2 = nullptr; #else - void * fp_vkCmdBeginRenderPass2{}; + void* fp_vkCmdBeginRenderPass2{}; #endif #if (defined(VK_VERSION_1_2)) PFN_vkCmdNextSubpass2 fp_vkCmdNextSubpass2 = nullptr; #else - void * fp_vkCmdNextSubpass2{}; + void* fp_vkCmdNextSubpass2{}; #endif #if (defined(VK_VERSION_1_2)) PFN_vkCmdEndRenderPass2 fp_vkCmdEndRenderPass2 = nullptr; #else - void * fp_vkCmdEndRenderPass2{}; + void* fp_vkCmdEndRenderPass2{}; #endif #if (defined(VK_VERSION_1_2)) PFN_vkGetSemaphoreCounterValue fp_vkGetSemaphoreCounterValue = nullptr; #else - void * fp_vkGetSemaphoreCounterValue{}; + void* fp_vkGetSemaphoreCounterValue{}; #endif #if (defined(VK_VERSION_1_2)) PFN_vkWaitSemaphores fp_vkWaitSemaphores = nullptr; #else - void * fp_vkWaitSemaphores{}; + void* fp_vkWaitSemaphores{}; #endif #if (defined(VK_VERSION_1_2)) PFN_vkSignalSemaphore fp_vkSignalSemaphore = nullptr; #else - void * fp_vkSignalSemaphore{}; + void* fp_vkSignalSemaphore{}; #endif #if (defined(VK_ANDROID_external_memory_android_hardware_buffer)) PFN_vkGetAndroidHardwareBufferPropertiesANDROID fp_vkGetAndroidHardwareBufferPropertiesANDROID = nullptr; #else - void * fp_vkGetAndroidHardwareBufferPropertiesANDROID{}; + void* fp_vkGetAndroidHardwareBufferPropertiesANDROID{}; #endif #if (defined(VK_ANDROID_external_memory_android_hardware_buffer)) PFN_vkGetMemoryAndroidHardwareBufferANDROID fp_vkGetMemoryAndroidHardwareBufferANDROID = nullptr; #else - void * fp_vkGetMemoryAndroidHardwareBufferANDROID{}; + void* fp_vkGetMemoryAndroidHardwareBufferANDROID{}; #endif #if (defined(VK_VERSION_1_2)) PFN_vkCmdDrawIndirectCount fp_vkCmdDrawIndirectCount = nullptr; #else - void * fp_vkCmdDrawIndirectCount{}; + void* fp_vkCmdDrawIndirectCount{}; #endif #if (defined(VK_VERSION_1_2)) PFN_vkCmdDrawIndexedIndirectCount fp_vkCmdDrawIndexedIndirectCount = nullptr; #else - void * fp_vkCmdDrawIndexedIndirectCount{}; + void* fp_vkCmdDrawIndexedIndirectCount{}; #endif #if (defined(VK_NV_device_diagnostic_checkpoints)) PFN_vkCmdSetCheckpointNV fp_vkCmdSetCheckpointNV = nullptr; #else - void * fp_vkCmdSetCheckpointNV{}; + void* fp_vkCmdSetCheckpointNV{}; #endif #if (defined(VK_NV_device_diagnostic_checkpoints)) PFN_vkGetQueueCheckpointDataNV fp_vkGetQueueCheckpointDataNV = nullptr; #else - void * fp_vkGetQueueCheckpointDataNV{}; + void* fp_vkGetQueueCheckpointDataNV{}; #endif #if (defined(VK_EXT_transform_feedback)) PFN_vkCmdBindTransformFeedbackBuffersEXT fp_vkCmdBindTransformFeedbackBuffersEXT = nullptr; #else - void * fp_vkCmdBindTransformFeedbackBuffersEXT{}; + void* fp_vkCmdBindTransformFeedbackBuffersEXT{}; #endif #if (defined(VK_EXT_transform_feedback)) PFN_vkCmdBeginTransformFeedbackEXT fp_vkCmdBeginTransformFeedbackEXT = nullptr; #else - void * fp_vkCmdBeginTransformFeedbackEXT{}; + void* fp_vkCmdBeginTransformFeedbackEXT{}; #endif #if (defined(VK_EXT_transform_feedback)) PFN_vkCmdEndTransformFeedbackEXT fp_vkCmdEndTransformFeedbackEXT = nullptr; #else - void * fp_vkCmdEndTransformFeedbackEXT{}; + void* fp_vkCmdEndTransformFeedbackEXT{}; #endif #if (defined(VK_EXT_transform_feedback)) PFN_vkCmdBeginQueryIndexedEXT fp_vkCmdBeginQueryIndexedEXT = nullptr; #else - void * fp_vkCmdBeginQueryIndexedEXT{}; + void* fp_vkCmdBeginQueryIndexedEXT{}; #endif #if (defined(VK_EXT_transform_feedback)) PFN_vkCmdEndQueryIndexedEXT fp_vkCmdEndQueryIndexedEXT = nullptr; #else - void * fp_vkCmdEndQueryIndexedEXT{}; + void* fp_vkCmdEndQueryIndexedEXT{}; #endif #if (defined(VK_EXT_transform_feedback)) PFN_vkCmdDrawIndirectByteCountEXT fp_vkCmdDrawIndirectByteCountEXT = nullptr; #else - void * fp_vkCmdDrawIndirectByteCountEXT{}; + void* fp_vkCmdDrawIndirectByteCountEXT{}; #endif #if (defined(VK_NV_scissor_exclusive)) PFN_vkCmdSetExclusiveScissorNV fp_vkCmdSetExclusiveScissorNV = nullptr; #else - void * fp_vkCmdSetExclusiveScissorNV{}; + void* fp_vkCmdSetExclusiveScissorNV{}; #endif #if ((defined(VK_NV_scissor_exclusive))) && VK_HEADER_VERSION >= 241 PFN_vkCmdSetExclusiveScissorEnableNV fp_vkCmdSetExclusiveScissorEnableNV = nullptr; #else - void * fp_vkCmdSetExclusiveScissorEnableNV{}; + void* fp_vkCmdSetExclusiveScissorEnableNV{}; #endif #if (defined(VK_NV_shading_rate_image)) PFN_vkCmdBindShadingRateImageNV fp_vkCmdBindShadingRateImageNV = nullptr; #else - void * fp_vkCmdBindShadingRateImageNV{}; + void* fp_vkCmdBindShadingRateImageNV{}; #endif #if (defined(VK_NV_shading_rate_image)) PFN_vkCmdSetViewportShadingRatePaletteNV fp_vkCmdSetViewportShadingRatePaletteNV = nullptr; #else - void * fp_vkCmdSetViewportShadingRatePaletteNV{}; + void* fp_vkCmdSetViewportShadingRatePaletteNV{}; #endif #if (defined(VK_NV_shading_rate_image)) PFN_vkCmdSetCoarseSampleOrderNV fp_vkCmdSetCoarseSampleOrderNV = nullptr; #else - void * fp_vkCmdSetCoarseSampleOrderNV{}; + void* fp_vkCmdSetCoarseSampleOrderNV{}; #endif #if (defined(VK_NV_mesh_shader)) PFN_vkCmdDrawMeshTasksNV fp_vkCmdDrawMeshTasksNV = nullptr; #else - void * fp_vkCmdDrawMeshTasksNV{}; + void* fp_vkCmdDrawMeshTasksNV{}; #endif #if (defined(VK_NV_mesh_shader)) PFN_vkCmdDrawMeshTasksIndirectNV fp_vkCmdDrawMeshTasksIndirectNV = nullptr; #else - void * fp_vkCmdDrawMeshTasksIndirectNV{}; + void* fp_vkCmdDrawMeshTasksIndirectNV{}; #endif #if (defined(VK_NV_mesh_shader)) PFN_vkCmdDrawMeshTasksIndirectCountNV fp_vkCmdDrawMeshTasksIndirectCountNV = nullptr; #else - void * fp_vkCmdDrawMeshTasksIndirectCountNV{}; + void* fp_vkCmdDrawMeshTasksIndirectCountNV{}; #endif #if (defined(VK_EXT_mesh_shader)) PFN_vkCmdDrawMeshTasksEXT fp_vkCmdDrawMeshTasksEXT = nullptr; #else - void * fp_vkCmdDrawMeshTasksEXT{}; + void* fp_vkCmdDrawMeshTasksEXT{}; #endif #if (defined(VK_EXT_mesh_shader)) PFN_vkCmdDrawMeshTasksIndirectEXT fp_vkCmdDrawMeshTasksIndirectEXT = nullptr; #else - void * fp_vkCmdDrawMeshTasksIndirectEXT{}; + void* fp_vkCmdDrawMeshTasksIndirectEXT{}; #endif #if (defined(VK_EXT_mesh_shader)) PFN_vkCmdDrawMeshTasksIndirectCountEXT fp_vkCmdDrawMeshTasksIndirectCountEXT = nullptr; #else - void * fp_vkCmdDrawMeshTasksIndirectCountEXT{}; + void* fp_vkCmdDrawMeshTasksIndirectCountEXT{}; #endif #if (defined(VK_NV_ray_tracing)) PFN_vkCompileDeferredNV fp_vkCompileDeferredNV = nullptr; #else - void * fp_vkCompileDeferredNV{}; + void* fp_vkCompileDeferredNV{}; #endif #if (defined(VK_NV_ray_tracing)) PFN_vkCreateAccelerationStructureNV fp_vkCreateAccelerationStructureNV = nullptr; #else - void * fp_vkCreateAccelerationStructureNV{}; + void* fp_vkCreateAccelerationStructureNV{}; #endif #if (defined(VK_HUAWEI_invocation_mask)) PFN_vkCmdBindInvocationMaskHUAWEI fp_vkCmdBindInvocationMaskHUAWEI = nullptr; #else - void * fp_vkCmdBindInvocationMaskHUAWEI{}; + void* fp_vkCmdBindInvocationMaskHUAWEI{}; #endif #if (defined(VK_KHR_acceleration_structure)) PFN_vkDestroyAccelerationStructureKHR fp_vkDestroyAccelerationStructureKHR = nullptr; #else - void * fp_vkDestroyAccelerationStructureKHR{}; + void* fp_vkDestroyAccelerationStructureKHR{}; #endif #if (defined(VK_NV_ray_tracing)) PFN_vkDestroyAccelerationStructureNV fp_vkDestroyAccelerationStructureNV = nullptr; #else - void * fp_vkDestroyAccelerationStructureNV{}; + void* fp_vkDestroyAccelerationStructureNV{}; #endif #if (defined(VK_NV_ray_tracing)) PFN_vkGetAccelerationStructureMemoryRequirementsNV fp_vkGetAccelerationStructureMemoryRequirementsNV = nullptr; #else - void * fp_vkGetAccelerationStructureMemoryRequirementsNV{}; + void* fp_vkGetAccelerationStructureMemoryRequirementsNV{}; #endif #if (defined(VK_NV_ray_tracing)) PFN_vkBindAccelerationStructureMemoryNV fp_vkBindAccelerationStructureMemoryNV = nullptr; #else - void * fp_vkBindAccelerationStructureMemoryNV{}; + void* fp_vkBindAccelerationStructureMemoryNV{}; #endif #if (defined(VK_NV_ray_tracing)) PFN_vkCmdCopyAccelerationStructureNV fp_vkCmdCopyAccelerationStructureNV = nullptr; #else - void * fp_vkCmdCopyAccelerationStructureNV{}; + void* fp_vkCmdCopyAccelerationStructureNV{}; #endif #if (defined(VK_KHR_acceleration_structure)) PFN_vkCmdCopyAccelerationStructureKHR fp_vkCmdCopyAccelerationStructureKHR = nullptr; #else - void * fp_vkCmdCopyAccelerationStructureKHR{}; + void* fp_vkCmdCopyAccelerationStructureKHR{}; #endif #if (defined(VK_KHR_acceleration_structure)) PFN_vkCopyAccelerationStructureKHR fp_vkCopyAccelerationStructureKHR = nullptr; #else - void * fp_vkCopyAccelerationStructureKHR{}; + void* fp_vkCopyAccelerationStructureKHR{}; #endif #if (defined(VK_KHR_acceleration_structure)) PFN_vkCmdCopyAccelerationStructureToMemoryKHR fp_vkCmdCopyAccelerationStructureToMemoryKHR = nullptr; #else - void * fp_vkCmdCopyAccelerationStructureToMemoryKHR{}; + void* fp_vkCmdCopyAccelerationStructureToMemoryKHR{}; #endif #if (defined(VK_KHR_acceleration_structure)) PFN_vkCopyAccelerationStructureToMemoryKHR fp_vkCopyAccelerationStructureToMemoryKHR = nullptr; #else - void * fp_vkCopyAccelerationStructureToMemoryKHR{}; + void* fp_vkCopyAccelerationStructureToMemoryKHR{}; #endif #if (defined(VK_KHR_acceleration_structure)) PFN_vkCmdCopyMemoryToAccelerationStructureKHR fp_vkCmdCopyMemoryToAccelerationStructureKHR = nullptr; #else - void * fp_vkCmdCopyMemoryToAccelerationStructureKHR{}; + void* fp_vkCmdCopyMemoryToAccelerationStructureKHR{}; #endif #if (defined(VK_KHR_acceleration_structure)) PFN_vkCopyMemoryToAccelerationStructureKHR fp_vkCopyMemoryToAccelerationStructureKHR = nullptr; #else - void * fp_vkCopyMemoryToAccelerationStructureKHR{}; + void* fp_vkCopyMemoryToAccelerationStructureKHR{}; #endif #if (defined(VK_KHR_acceleration_structure)) PFN_vkCmdWriteAccelerationStructuresPropertiesKHR fp_vkCmdWriteAccelerationStructuresPropertiesKHR = nullptr; #else - void * fp_vkCmdWriteAccelerationStructuresPropertiesKHR{}; + void* fp_vkCmdWriteAccelerationStructuresPropertiesKHR{}; #endif #if (defined(VK_NV_ray_tracing)) PFN_vkCmdWriteAccelerationStructuresPropertiesNV fp_vkCmdWriteAccelerationStructuresPropertiesNV = nullptr; #else - void * fp_vkCmdWriteAccelerationStructuresPropertiesNV{}; + void* fp_vkCmdWriteAccelerationStructuresPropertiesNV{}; #endif #if (defined(VK_NV_ray_tracing)) PFN_vkCmdBuildAccelerationStructureNV fp_vkCmdBuildAccelerationStructureNV = nullptr; #else - void * fp_vkCmdBuildAccelerationStructureNV{}; + void* fp_vkCmdBuildAccelerationStructureNV{}; #endif #if (defined(VK_KHR_acceleration_structure)) PFN_vkWriteAccelerationStructuresPropertiesKHR fp_vkWriteAccelerationStructuresPropertiesKHR = nullptr; #else - void * fp_vkWriteAccelerationStructuresPropertiesKHR{}; + void* fp_vkWriteAccelerationStructuresPropertiesKHR{}; #endif #if (defined(VK_KHR_ray_tracing_pipeline)) PFN_vkCmdTraceRaysKHR fp_vkCmdTraceRaysKHR = nullptr; #else - void * fp_vkCmdTraceRaysKHR{}; + void* fp_vkCmdTraceRaysKHR{}; #endif #if (defined(VK_NV_ray_tracing)) PFN_vkCmdTraceRaysNV fp_vkCmdTraceRaysNV = nullptr; #else - void * fp_vkCmdTraceRaysNV{}; + void* fp_vkCmdTraceRaysNV{}; #endif #if (defined(VK_KHR_ray_tracing_pipeline)) PFN_vkGetRayTracingShaderGroupHandlesKHR fp_vkGetRayTracingShaderGroupHandlesKHR = nullptr; #else - void * fp_vkGetRayTracingShaderGroupHandlesKHR{}; + void* fp_vkGetRayTracingShaderGroupHandlesKHR{}; #endif #if (defined(VK_KHR_ray_tracing_pipeline)) - PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR fp_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = nullptr; + PFN_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR fp_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR = + nullptr; #else - void * fp_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR{}; + void* fp_vkGetRayTracingCaptureReplayShaderGroupHandlesKHR{}; #endif #if (defined(VK_NV_ray_tracing)) PFN_vkGetAccelerationStructureHandleNV fp_vkGetAccelerationStructureHandleNV = nullptr; #else - void * fp_vkGetAccelerationStructureHandleNV{}; + void* fp_vkGetAccelerationStructureHandleNV{}; #endif #if (defined(VK_NV_ray_tracing)) PFN_vkCreateRayTracingPipelinesNV fp_vkCreateRayTracingPipelinesNV = nullptr; #else - void * fp_vkCreateRayTracingPipelinesNV{}; + void* fp_vkCreateRayTracingPipelinesNV{}; #endif #if (defined(VK_KHR_ray_tracing_pipeline)) PFN_vkCreateRayTracingPipelinesKHR fp_vkCreateRayTracingPipelinesKHR = nullptr; #else - void * fp_vkCreateRayTracingPipelinesKHR{}; + void* fp_vkCreateRayTracingPipelinesKHR{}; #endif #if (defined(VK_KHR_ray_tracing_pipeline)) PFN_vkCmdTraceRaysIndirectKHR fp_vkCmdTraceRaysIndirectKHR = nullptr; #else - void * fp_vkCmdTraceRaysIndirectKHR{}; + void* fp_vkCmdTraceRaysIndirectKHR{}; #endif #if (defined(VK_KHR_ray_tracing_maintenance1)) PFN_vkCmdTraceRaysIndirect2KHR fp_vkCmdTraceRaysIndirect2KHR = nullptr; #else - void * fp_vkCmdTraceRaysIndirect2KHR{}; + void* fp_vkCmdTraceRaysIndirect2KHR{}; #endif #if (defined(VK_KHR_acceleration_structure)) PFN_vkGetDeviceAccelerationStructureCompatibilityKHR fp_vkGetDeviceAccelerationStructureCompatibilityKHR = nullptr; #else - void * fp_vkGetDeviceAccelerationStructureCompatibilityKHR{}; + void* fp_vkGetDeviceAccelerationStructureCompatibilityKHR{}; #endif #if (defined(VK_KHR_ray_tracing_pipeline)) PFN_vkGetRayTracingShaderGroupStackSizeKHR fp_vkGetRayTracingShaderGroupStackSizeKHR = nullptr; #else - void * fp_vkGetRayTracingShaderGroupStackSizeKHR{}; + void* fp_vkGetRayTracingShaderGroupStackSizeKHR{}; #endif #if (defined(VK_KHR_ray_tracing_pipeline)) PFN_vkCmdSetRayTracingPipelineStackSizeKHR fp_vkCmdSetRayTracingPipelineStackSizeKHR = nullptr; #else - void * fp_vkCmdSetRayTracingPipelineStackSizeKHR{}; + void* fp_vkCmdSetRayTracingPipelineStackSizeKHR{}; #endif #if (defined(VK_EXT_full_screen_exclusive)) PFN_vkGetDeviceGroupSurfacePresentModes2EXT fp_vkGetDeviceGroupSurfacePresentModes2EXT = nullptr; #else - void * fp_vkGetDeviceGroupSurfacePresentModes2EXT{}; + void* fp_vkGetDeviceGroupSurfacePresentModes2EXT{}; #endif #if (defined(VK_EXT_full_screen_exclusive)) PFN_vkAcquireFullScreenExclusiveModeEXT fp_vkAcquireFullScreenExclusiveModeEXT = nullptr; #else - void * fp_vkAcquireFullScreenExclusiveModeEXT{}; + void* fp_vkAcquireFullScreenExclusiveModeEXT{}; #endif #if (defined(VK_EXT_full_screen_exclusive)) PFN_vkReleaseFullScreenExclusiveModeEXT fp_vkReleaseFullScreenExclusiveModeEXT = nullptr; #else - void * fp_vkReleaseFullScreenExclusiveModeEXT{}; + void* fp_vkReleaseFullScreenExclusiveModeEXT{}; #endif #if (defined(VK_KHR_performance_query)) PFN_vkAcquireProfilingLockKHR fp_vkAcquireProfilingLockKHR = nullptr; #else - void * fp_vkAcquireProfilingLockKHR{}; + void* fp_vkAcquireProfilingLockKHR{}; #endif #if (defined(VK_KHR_performance_query)) PFN_vkReleaseProfilingLockKHR fp_vkReleaseProfilingLockKHR = nullptr; #else - void * fp_vkReleaseProfilingLockKHR{}; + void* fp_vkReleaseProfilingLockKHR{}; #endif #if (defined(VK_EXT_image_drm_format_modifier)) PFN_vkGetImageDrmFormatModifierPropertiesEXT fp_vkGetImageDrmFormatModifierPropertiesEXT = nullptr; #else - void * fp_vkGetImageDrmFormatModifierPropertiesEXT{}; + void* fp_vkGetImageDrmFormatModifierPropertiesEXT{}; #endif #if (defined(VK_VERSION_1_2)) PFN_vkGetBufferOpaqueCaptureAddress fp_vkGetBufferOpaqueCaptureAddress = nullptr; #else - void * fp_vkGetBufferOpaqueCaptureAddress{}; + void* fp_vkGetBufferOpaqueCaptureAddress{}; #endif #if (defined(VK_VERSION_1_2)) PFN_vkGetBufferDeviceAddress fp_vkGetBufferDeviceAddress = nullptr; #else - void * fp_vkGetBufferDeviceAddress{}; + void* fp_vkGetBufferDeviceAddress{}; #endif #if (defined(VK_INTEL_performance_query)) PFN_vkInitializePerformanceApiINTEL fp_vkInitializePerformanceApiINTEL = nullptr; #else - void * fp_vkInitializePerformanceApiINTEL{}; + void* fp_vkInitializePerformanceApiINTEL{}; #endif #if (defined(VK_INTEL_performance_query)) PFN_vkUninitializePerformanceApiINTEL fp_vkUninitializePerformanceApiINTEL = nullptr; #else - void * fp_vkUninitializePerformanceApiINTEL{}; + void* fp_vkUninitializePerformanceApiINTEL{}; #endif #if (defined(VK_INTEL_performance_query)) PFN_vkCmdSetPerformanceMarkerINTEL fp_vkCmdSetPerformanceMarkerINTEL = nullptr; #else - void * fp_vkCmdSetPerformanceMarkerINTEL{}; + void* fp_vkCmdSetPerformanceMarkerINTEL{}; #endif #if (defined(VK_INTEL_performance_query)) PFN_vkCmdSetPerformanceStreamMarkerINTEL fp_vkCmdSetPerformanceStreamMarkerINTEL = nullptr; #else - void * fp_vkCmdSetPerformanceStreamMarkerINTEL{}; + void* fp_vkCmdSetPerformanceStreamMarkerINTEL{}; #endif #if (defined(VK_INTEL_performance_query)) PFN_vkCmdSetPerformanceOverrideINTEL fp_vkCmdSetPerformanceOverrideINTEL = nullptr; #else - void * fp_vkCmdSetPerformanceOverrideINTEL{}; + void* fp_vkCmdSetPerformanceOverrideINTEL{}; #endif #if (defined(VK_INTEL_performance_query)) PFN_vkAcquirePerformanceConfigurationINTEL fp_vkAcquirePerformanceConfigurationINTEL = nullptr; #else - void * fp_vkAcquirePerformanceConfigurationINTEL{}; + void* fp_vkAcquirePerformanceConfigurationINTEL{}; #endif #if (defined(VK_INTEL_performance_query)) PFN_vkReleasePerformanceConfigurationINTEL fp_vkReleasePerformanceConfigurationINTEL = nullptr; #else - void * fp_vkReleasePerformanceConfigurationINTEL{}; + void* fp_vkReleasePerformanceConfigurationINTEL{}; #endif #if (defined(VK_INTEL_performance_query)) PFN_vkQueueSetPerformanceConfigurationINTEL fp_vkQueueSetPerformanceConfigurationINTEL = nullptr; #else - void * fp_vkQueueSetPerformanceConfigurationINTEL{}; + void* fp_vkQueueSetPerformanceConfigurationINTEL{}; #endif #if (defined(VK_INTEL_performance_query)) PFN_vkGetPerformanceParameterINTEL fp_vkGetPerformanceParameterINTEL = nullptr; #else - void * fp_vkGetPerformanceParameterINTEL{}; + void* fp_vkGetPerformanceParameterINTEL{}; #endif #if (defined(VK_VERSION_1_2)) PFN_vkGetDeviceMemoryOpaqueCaptureAddress fp_vkGetDeviceMemoryOpaqueCaptureAddress = nullptr; #else - void * fp_vkGetDeviceMemoryOpaqueCaptureAddress{}; + void* fp_vkGetDeviceMemoryOpaqueCaptureAddress{}; #endif #if (defined(VK_KHR_pipeline_executable_properties)) PFN_vkGetPipelineExecutablePropertiesKHR fp_vkGetPipelineExecutablePropertiesKHR = nullptr; #else - void * fp_vkGetPipelineExecutablePropertiesKHR{}; + void* fp_vkGetPipelineExecutablePropertiesKHR{}; #endif #if (defined(VK_KHR_pipeline_executable_properties)) PFN_vkGetPipelineExecutableStatisticsKHR fp_vkGetPipelineExecutableStatisticsKHR = nullptr; #else - void * fp_vkGetPipelineExecutableStatisticsKHR{}; + void* fp_vkGetPipelineExecutableStatisticsKHR{}; #endif #if (defined(VK_KHR_pipeline_executable_properties)) - PFN_vkGetPipelineExecutableInternalRepresentationsKHR fp_vkGetPipelineExecutableInternalRepresentationsKHR = nullptr; + PFN_vkGetPipelineExecutableInternalRepresentationsKHR fp_vkGetPipelineExecutableInternalRepresentationsKHR = + nullptr; #else - void * fp_vkGetPipelineExecutableInternalRepresentationsKHR{}; + void* fp_vkGetPipelineExecutableInternalRepresentationsKHR{}; #endif #if (defined(VK_KHR_line_rasterization)) PFN_vkCmdSetLineStippleKHR fp_vkCmdSetLineStippleKHR = nullptr; #else - void * fp_vkCmdSetLineStippleKHR{}; + void* fp_vkCmdSetLineStippleKHR{}; #endif #if (defined(VKSC_VERSION_1_0)) PFN_vkGetFaultData fp_vkGetFaultData = nullptr; #else - void * fp_vkGetFaultData{}; + void* fp_vkGetFaultData{}; #endif #if (defined(VK_KHR_acceleration_structure)) PFN_vkCreateAccelerationStructureKHR fp_vkCreateAccelerationStructureKHR = nullptr; #else - void * fp_vkCreateAccelerationStructureKHR{}; + void* fp_vkCreateAccelerationStructureKHR{}; #endif #if (defined(VK_KHR_acceleration_structure)) PFN_vkCmdBuildAccelerationStructuresKHR fp_vkCmdBuildAccelerationStructuresKHR = nullptr; #else - void * fp_vkCmdBuildAccelerationStructuresKHR{}; + void* fp_vkCmdBuildAccelerationStructuresKHR{}; #endif #if (defined(VK_KHR_acceleration_structure)) PFN_vkCmdBuildAccelerationStructuresIndirectKHR fp_vkCmdBuildAccelerationStructuresIndirectKHR = nullptr; #else - void * fp_vkCmdBuildAccelerationStructuresIndirectKHR{}; + void* fp_vkCmdBuildAccelerationStructuresIndirectKHR{}; #endif #if (defined(VK_KHR_acceleration_structure)) PFN_vkBuildAccelerationStructuresKHR fp_vkBuildAccelerationStructuresKHR = nullptr; #else - void * fp_vkBuildAccelerationStructuresKHR{}; + void* fp_vkBuildAccelerationStructuresKHR{}; #endif #if (defined(VK_KHR_acceleration_structure)) PFN_vkGetAccelerationStructureDeviceAddressKHR fp_vkGetAccelerationStructureDeviceAddressKHR = nullptr; #else - void * fp_vkGetAccelerationStructureDeviceAddressKHR{}; + void* fp_vkGetAccelerationStructureDeviceAddressKHR{}; #endif #if (defined(VK_KHR_deferred_host_operations)) PFN_vkCreateDeferredOperationKHR fp_vkCreateDeferredOperationKHR = nullptr; #else - void * fp_vkCreateDeferredOperationKHR{}; + void* fp_vkCreateDeferredOperationKHR{}; #endif #if (defined(VK_KHR_deferred_host_operations)) PFN_vkDestroyDeferredOperationKHR fp_vkDestroyDeferredOperationKHR = nullptr; #else - void * fp_vkDestroyDeferredOperationKHR{}; + void* fp_vkDestroyDeferredOperationKHR{}; #endif #if (defined(VK_KHR_deferred_host_operations)) PFN_vkGetDeferredOperationMaxConcurrencyKHR fp_vkGetDeferredOperationMaxConcurrencyKHR = nullptr; #else - void * fp_vkGetDeferredOperationMaxConcurrencyKHR{}; + void* fp_vkGetDeferredOperationMaxConcurrencyKHR{}; #endif #if (defined(VK_KHR_deferred_host_operations)) PFN_vkGetDeferredOperationResultKHR fp_vkGetDeferredOperationResultKHR = nullptr; #else - void * fp_vkGetDeferredOperationResultKHR{}; + void* fp_vkGetDeferredOperationResultKHR{}; #endif #if (defined(VK_KHR_deferred_host_operations)) PFN_vkDeferredOperationJoinKHR fp_vkDeferredOperationJoinKHR = nullptr; #else - void * fp_vkDeferredOperationJoinKHR{}; + void* fp_vkDeferredOperationJoinKHR{}; #endif #if (defined(VK_NV_device_generated_commands_compute)) PFN_vkGetPipelineIndirectMemoryRequirementsNV fp_vkGetPipelineIndirectMemoryRequirementsNV = nullptr; #else - void * fp_vkGetPipelineIndirectMemoryRequirementsNV{}; + void* fp_vkGetPipelineIndirectMemoryRequirementsNV{}; #endif #if (defined(VK_NV_device_generated_commands_compute)) PFN_vkGetPipelineIndirectDeviceAddressNV fp_vkGetPipelineIndirectDeviceAddressNV = nullptr; #else - void * fp_vkGetPipelineIndirectDeviceAddressNV{}; + void* fp_vkGetPipelineIndirectDeviceAddressNV{}; #endif #if (defined(VK_AMD_anti_lag)) PFN_vkAntiLagUpdateAMD fp_vkAntiLagUpdateAMD = nullptr; #else - void * fp_vkAntiLagUpdateAMD{}; + void* fp_vkAntiLagUpdateAMD{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdSetCullMode fp_vkCmdSetCullMode = nullptr; #else - void * fp_vkCmdSetCullMode{}; + void* fp_vkCmdSetCullMode{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdSetFrontFace fp_vkCmdSetFrontFace = nullptr; #else - void * fp_vkCmdSetFrontFace{}; + void* fp_vkCmdSetFrontFace{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdSetPrimitiveTopology fp_vkCmdSetPrimitiveTopology = nullptr; #else - void * fp_vkCmdSetPrimitiveTopology{}; + void* fp_vkCmdSetPrimitiveTopology{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdSetViewportWithCount fp_vkCmdSetViewportWithCount = nullptr; #else - void * fp_vkCmdSetViewportWithCount{}; + void* fp_vkCmdSetViewportWithCount{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdSetScissorWithCount fp_vkCmdSetScissorWithCount = nullptr; #else - void * fp_vkCmdSetScissorWithCount{}; + void* fp_vkCmdSetScissorWithCount{}; #endif #if (defined(VK_KHR_maintenance5)) PFN_vkCmdBindIndexBuffer2KHR fp_vkCmdBindIndexBuffer2KHR = nullptr; #else - void * fp_vkCmdBindIndexBuffer2KHR{}; + void* fp_vkCmdBindIndexBuffer2KHR{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdBindVertexBuffers2 fp_vkCmdBindVertexBuffers2 = nullptr; #else - void * fp_vkCmdBindVertexBuffers2{}; + void* fp_vkCmdBindVertexBuffers2{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdSetDepthTestEnable fp_vkCmdSetDepthTestEnable = nullptr; #else - void * fp_vkCmdSetDepthTestEnable{}; + void* fp_vkCmdSetDepthTestEnable{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdSetDepthWriteEnable fp_vkCmdSetDepthWriteEnable = nullptr; #else - void * fp_vkCmdSetDepthWriteEnable{}; + void* fp_vkCmdSetDepthWriteEnable{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdSetDepthCompareOp fp_vkCmdSetDepthCompareOp = nullptr; #else - void * fp_vkCmdSetDepthCompareOp{}; + void* fp_vkCmdSetDepthCompareOp{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdSetDepthBoundsTestEnable fp_vkCmdSetDepthBoundsTestEnable = nullptr; #else - void * fp_vkCmdSetDepthBoundsTestEnable{}; + void* fp_vkCmdSetDepthBoundsTestEnable{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdSetStencilTestEnable fp_vkCmdSetStencilTestEnable = nullptr; #else - void * fp_vkCmdSetStencilTestEnable{}; + void* fp_vkCmdSetStencilTestEnable{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdSetStencilOp fp_vkCmdSetStencilOp = nullptr; #else - void * fp_vkCmdSetStencilOp{}; + void* fp_vkCmdSetStencilOp{}; #endif #if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetPatchControlPointsEXT fp_vkCmdSetPatchControlPointsEXT = nullptr; #else - void * fp_vkCmdSetPatchControlPointsEXT{}; + void* fp_vkCmdSetPatchControlPointsEXT{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdSetRasterizerDiscardEnable fp_vkCmdSetRasterizerDiscardEnable = nullptr; #else - void * fp_vkCmdSetRasterizerDiscardEnable{}; + void* fp_vkCmdSetRasterizerDiscardEnable{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdSetDepthBiasEnable fp_vkCmdSetDepthBiasEnable = nullptr; #else - void * fp_vkCmdSetDepthBiasEnable{}; + void* fp_vkCmdSetDepthBiasEnable{}; #endif #if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetLogicOpEXT fp_vkCmdSetLogicOpEXT = nullptr; #else - void * fp_vkCmdSetLogicOpEXT{}; + void* fp_vkCmdSetLogicOpEXT{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdSetPrimitiveRestartEnable fp_vkCmdSetPrimitiveRestartEnable = nullptr; #else - void * fp_vkCmdSetPrimitiveRestartEnable{}; + void* fp_vkCmdSetPrimitiveRestartEnable{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetTessellationDomainOriginEXT fp_vkCmdSetTessellationDomainOriginEXT = nullptr; #else - void * fp_vkCmdSetTessellationDomainOriginEXT{}; + void* fp_vkCmdSetTessellationDomainOriginEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetDepthClampEnableEXT fp_vkCmdSetDepthClampEnableEXT = nullptr; #else - void * fp_vkCmdSetDepthClampEnableEXT{}; + void* fp_vkCmdSetDepthClampEnableEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetPolygonModeEXT fp_vkCmdSetPolygonModeEXT = nullptr; #else - void * fp_vkCmdSetPolygonModeEXT{}; + void* fp_vkCmdSetPolygonModeEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetRasterizationSamplesEXT fp_vkCmdSetRasterizationSamplesEXT = nullptr; #else - void * fp_vkCmdSetRasterizationSamplesEXT{}; + void* fp_vkCmdSetRasterizationSamplesEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetSampleMaskEXT fp_vkCmdSetSampleMaskEXT = nullptr; #else - void * fp_vkCmdSetSampleMaskEXT{}; + void* fp_vkCmdSetSampleMaskEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetAlphaToCoverageEnableEXT fp_vkCmdSetAlphaToCoverageEnableEXT = nullptr; #else - void * fp_vkCmdSetAlphaToCoverageEnableEXT{}; + void* fp_vkCmdSetAlphaToCoverageEnableEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetAlphaToOneEnableEXT fp_vkCmdSetAlphaToOneEnableEXT = nullptr; #else - void * fp_vkCmdSetAlphaToOneEnableEXT{}; + void* fp_vkCmdSetAlphaToOneEnableEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetLogicOpEnableEXT fp_vkCmdSetLogicOpEnableEXT = nullptr; #else - void * fp_vkCmdSetLogicOpEnableEXT{}; + void* fp_vkCmdSetLogicOpEnableEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetColorBlendEnableEXT fp_vkCmdSetColorBlendEnableEXT = nullptr; #else - void * fp_vkCmdSetColorBlendEnableEXT{}; + void* fp_vkCmdSetColorBlendEnableEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetColorBlendEquationEXT fp_vkCmdSetColorBlendEquationEXT = nullptr; #else - void * fp_vkCmdSetColorBlendEquationEXT{}; + void* fp_vkCmdSetColorBlendEquationEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetColorWriteMaskEXT fp_vkCmdSetColorWriteMaskEXT = nullptr; #else - void * fp_vkCmdSetColorWriteMaskEXT{}; + void* fp_vkCmdSetColorWriteMaskEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetRasterizationStreamEXT fp_vkCmdSetRasterizationStreamEXT = nullptr; #else - void * fp_vkCmdSetRasterizationStreamEXT{}; + void* fp_vkCmdSetRasterizationStreamEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetConservativeRasterizationModeEXT fp_vkCmdSetConservativeRasterizationModeEXT = nullptr; #else - void * fp_vkCmdSetConservativeRasterizationModeEXT{}; + void* fp_vkCmdSetConservativeRasterizationModeEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetExtraPrimitiveOverestimationSizeEXT fp_vkCmdSetExtraPrimitiveOverestimationSizeEXT = nullptr; #else - void * fp_vkCmdSetExtraPrimitiveOverestimationSizeEXT{}; + void* fp_vkCmdSetExtraPrimitiveOverestimationSizeEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetDepthClipEnableEXT fp_vkCmdSetDepthClipEnableEXT = nullptr; #else - void * fp_vkCmdSetDepthClipEnableEXT{}; + void* fp_vkCmdSetDepthClipEnableEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetSampleLocationsEnableEXT fp_vkCmdSetSampleLocationsEnableEXT = nullptr; #else - void * fp_vkCmdSetSampleLocationsEnableEXT{}; + void* fp_vkCmdSetSampleLocationsEnableEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetColorBlendAdvancedEXT fp_vkCmdSetColorBlendAdvancedEXT = nullptr; #else - void * fp_vkCmdSetColorBlendAdvancedEXT{}; + void* fp_vkCmdSetColorBlendAdvancedEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetProvokingVertexModeEXT fp_vkCmdSetProvokingVertexModeEXT = nullptr; #else - void * fp_vkCmdSetProvokingVertexModeEXT{}; + void* fp_vkCmdSetProvokingVertexModeEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetLineRasterizationModeEXT fp_vkCmdSetLineRasterizationModeEXT = nullptr; #else - void * fp_vkCmdSetLineRasterizationModeEXT{}; + void* fp_vkCmdSetLineRasterizationModeEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetLineStippleEnableEXT fp_vkCmdSetLineStippleEnableEXT = nullptr; #else - void * fp_vkCmdSetLineStippleEnableEXT{}; + void* fp_vkCmdSetLineStippleEnableEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetDepthClipNegativeOneToOneEXT fp_vkCmdSetDepthClipNegativeOneToOneEXT = nullptr; #else - void * fp_vkCmdSetDepthClipNegativeOneToOneEXT{}; + void* fp_vkCmdSetDepthClipNegativeOneToOneEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetViewportWScalingEnableNV fp_vkCmdSetViewportWScalingEnableNV = nullptr; #else - void * fp_vkCmdSetViewportWScalingEnableNV{}; + void* fp_vkCmdSetViewportWScalingEnableNV{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetViewportSwizzleNV fp_vkCmdSetViewportSwizzleNV = nullptr; #else - void * fp_vkCmdSetViewportSwizzleNV{}; + void* fp_vkCmdSetViewportSwizzleNV{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetCoverageToColorEnableNV fp_vkCmdSetCoverageToColorEnableNV = nullptr; #else - void * fp_vkCmdSetCoverageToColorEnableNV{}; + void* fp_vkCmdSetCoverageToColorEnableNV{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetCoverageToColorLocationNV fp_vkCmdSetCoverageToColorLocationNV = nullptr; #else - void * fp_vkCmdSetCoverageToColorLocationNV{}; + void* fp_vkCmdSetCoverageToColorLocationNV{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetCoverageModulationModeNV fp_vkCmdSetCoverageModulationModeNV = nullptr; #else - void * fp_vkCmdSetCoverageModulationModeNV{}; + void* fp_vkCmdSetCoverageModulationModeNV{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetCoverageModulationTableEnableNV fp_vkCmdSetCoverageModulationTableEnableNV = nullptr; #else - void * fp_vkCmdSetCoverageModulationTableEnableNV{}; + void* fp_vkCmdSetCoverageModulationTableEnableNV{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetCoverageModulationTableNV fp_vkCmdSetCoverageModulationTableNV = nullptr; #else - void * fp_vkCmdSetCoverageModulationTableNV{}; + void* fp_vkCmdSetCoverageModulationTableNV{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetShadingRateImageEnableNV fp_vkCmdSetShadingRateImageEnableNV = nullptr; #else - void * fp_vkCmdSetShadingRateImageEnableNV{}; + void* fp_vkCmdSetShadingRateImageEnableNV{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetCoverageReductionModeNV fp_vkCmdSetCoverageReductionModeNV = nullptr; #else - void * fp_vkCmdSetCoverageReductionModeNV{}; + void* fp_vkCmdSetCoverageReductionModeNV{}; #endif #if (defined(VK_EXT_extended_dynamic_state3)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetRepresentativeFragmentTestEnableNV fp_vkCmdSetRepresentativeFragmentTestEnableNV = nullptr; #else - void * fp_vkCmdSetRepresentativeFragmentTestEnableNV{}; + void* fp_vkCmdSetRepresentativeFragmentTestEnableNV{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCreatePrivateDataSlot fp_vkCreatePrivateDataSlot = nullptr; #else - void * fp_vkCreatePrivateDataSlot{}; + void* fp_vkCreatePrivateDataSlot{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkDestroyPrivateDataSlot fp_vkDestroyPrivateDataSlot = nullptr; #else - void * fp_vkDestroyPrivateDataSlot{}; + void* fp_vkDestroyPrivateDataSlot{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkSetPrivateData fp_vkSetPrivateData = nullptr; #else - void * fp_vkSetPrivateData{}; + void* fp_vkSetPrivateData{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkGetPrivateData fp_vkGetPrivateData = nullptr; #else - void * fp_vkGetPrivateData{}; + void* fp_vkGetPrivateData{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdCopyBuffer2 fp_vkCmdCopyBuffer2 = nullptr; #else - void * fp_vkCmdCopyBuffer2{}; + void* fp_vkCmdCopyBuffer2{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdCopyImage2 fp_vkCmdCopyImage2 = nullptr; #else - void * fp_vkCmdCopyImage2{}; + void* fp_vkCmdCopyImage2{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdBlitImage2 fp_vkCmdBlitImage2 = nullptr; #else - void * fp_vkCmdBlitImage2{}; + void* fp_vkCmdBlitImage2{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdCopyBufferToImage2 fp_vkCmdCopyBufferToImage2 = nullptr; #else - void * fp_vkCmdCopyBufferToImage2{}; + void* fp_vkCmdCopyBufferToImage2{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdCopyImageToBuffer2 fp_vkCmdCopyImageToBuffer2 = nullptr; #else - void * fp_vkCmdCopyImageToBuffer2{}; + void* fp_vkCmdCopyImageToBuffer2{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdResolveImage2 fp_vkCmdResolveImage2 = nullptr; #else - void * fp_vkCmdResolveImage2{}; + void* fp_vkCmdResolveImage2{}; #endif #if (defined(VK_KHR_object_refresh)) PFN_vkCmdRefreshObjectsKHR fp_vkCmdRefreshObjectsKHR = nullptr; #else - void * fp_vkCmdRefreshObjectsKHR{}; + void* fp_vkCmdRefreshObjectsKHR{}; #endif #if (defined(VK_KHR_fragment_shading_rate)) PFN_vkCmdSetFragmentShadingRateKHR fp_vkCmdSetFragmentShadingRateKHR = nullptr; #else - void * fp_vkCmdSetFragmentShadingRateKHR{}; + void* fp_vkCmdSetFragmentShadingRateKHR{}; #endif #if (defined(VK_NV_fragment_shading_rate_enums)) PFN_vkCmdSetFragmentShadingRateEnumNV fp_vkCmdSetFragmentShadingRateEnumNV = nullptr; #else - void * fp_vkCmdSetFragmentShadingRateEnumNV{}; + void* fp_vkCmdSetFragmentShadingRateEnumNV{}; #endif #if (defined(VK_KHR_acceleration_structure)) PFN_vkGetAccelerationStructureBuildSizesKHR fp_vkGetAccelerationStructureBuildSizesKHR = nullptr; #else - void * fp_vkGetAccelerationStructureBuildSizesKHR{}; + void* fp_vkGetAccelerationStructureBuildSizesKHR{}; #endif #if (defined(VK_EXT_vertex_input_dynamic_state)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetVertexInputEXT fp_vkCmdSetVertexInputEXT = nullptr; #else - void * fp_vkCmdSetVertexInputEXT{}; + void* fp_vkCmdSetVertexInputEXT{}; #endif #if (defined(VK_EXT_color_write_enable)) PFN_vkCmdSetColorWriteEnableEXT fp_vkCmdSetColorWriteEnableEXT = nullptr; #else - void * fp_vkCmdSetColorWriteEnableEXT{}; + void* fp_vkCmdSetColorWriteEnableEXT{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdSetEvent2 fp_vkCmdSetEvent2 = nullptr; #else - void * fp_vkCmdSetEvent2{}; + void* fp_vkCmdSetEvent2{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdResetEvent2 fp_vkCmdResetEvent2 = nullptr; #else - void * fp_vkCmdResetEvent2{}; + void* fp_vkCmdResetEvent2{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdWaitEvents2 fp_vkCmdWaitEvents2 = nullptr; #else - void * fp_vkCmdWaitEvents2{}; + void* fp_vkCmdWaitEvents2{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdPipelineBarrier2 fp_vkCmdPipelineBarrier2 = nullptr; #else - void * fp_vkCmdPipelineBarrier2{}; + void* fp_vkCmdPipelineBarrier2{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkQueueSubmit2 fp_vkQueueSubmit2 = nullptr; #else - void * fp_vkQueueSubmit2{}; + void* fp_vkQueueSubmit2{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdWriteTimestamp2 fp_vkCmdWriteTimestamp2 = nullptr; #else - void * fp_vkCmdWriteTimestamp2{}; + void* fp_vkCmdWriteTimestamp2{}; #endif #if (defined(VK_KHR_synchronization2)) PFN_vkCmdWriteBufferMarker2AMD fp_vkCmdWriteBufferMarker2AMD = nullptr; #else - void * fp_vkCmdWriteBufferMarker2AMD{}; + void* fp_vkCmdWriteBufferMarker2AMD{}; #endif #if (defined(VK_KHR_synchronization2)) PFN_vkGetQueueCheckpointData2NV fp_vkGetQueueCheckpointData2NV = nullptr; #else - void * fp_vkGetQueueCheckpointData2NV{}; + void* fp_vkGetQueueCheckpointData2NV{}; #endif #if (defined(VK_EXT_host_image_copy)) PFN_vkCopyMemoryToImageEXT fp_vkCopyMemoryToImageEXT = nullptr; #else - void * fp_vkCopyMemoryToImageEXT{}; + void* fp_vkCopyMemoryToImageEXT{}; #endif #if (defined(VK_EXT_host_image_copy)) PFN_vkCopyImageToMemoryEXT fp_vkCopyImageToMemoryEXT = nullptr; #else - void * fp_vkCopyImageToMemoryEXT{}; + void* fp_vkCopyImageToMemoryEXT{}; #endif #if (defined(VK_EXT_host_image_copy)) PFN_vkCopyImageToImageEXT fp_vkCopyImageToImageEXT = nullptr; #else - void * fp_vkCopyImageToImageEXT{}; + void* fp_vkCopyImageToImageEXT{}; #endif #if (defined(VK_EXT_host_image_copy)) PFN_vkTransitionImageLayoutEXT fp_vkTransitionImageLayoutEXT = nullptr; #else - void * fp_vkTransitionImageLayoutEXT{}; + void* fp_vkTransitionImageLayoutEXT{}; #endif #if (defined(VKSC_VERSION_1_0)) PFN_vkGetCommandPoolMemoryConsumption fp_vkGetCommandPoolMemoryConsumption = nullptr; #else - void * fp_vkGetCommandPoolMemoryConsumption{}; + void* fp_vkGetCommandPoolMemoryConsumption{}; #endif #if (defined(VK_KHR_video_queue)) PFN_vkCreateVideoSessionKHR fp_vkCreateVideoSessionKHR = nullptr; #else - void * fp_vkCreateVideoSessionKHR{}; + void* fp_vkCreateVideoSessionKHR{}; #endif #if (defined(VK_KHR_video_queue)) PFN_vkDestroyVideoSessionKHR fp_vkDestroyVideoSessionKHR = nullptr; #else - void * fp_vkDestroyVideoSessionKHR{}; + void* fp_vkDestroyVideoSessionKHR{}; #endif #if (defined(VK_KHR_video_queue)) PFN_vkCreateVideoSessionParametersKHR fp_vkCreateVideoSessionParametersKHR = nullptr; #else - void * fp_vkCreateVideoSessionParametersKHR{}; + void* fp_vkCreateVideoSessionParametersKHR{}; #endif #if (defined(VK_KHR_video_queue)) PFN_vkUpdateVideoSessionParametersKHR fp_vkUpdateVideoSessionParametersKHR = nullptr; #else - void * fp_vkUpdateVideoSessionParametersKHR{}; + void* fp_vkUpdateVideoSessionParametersKHR{}; #endif #if (defined(VK_KHR_video_encode_queue)) PFN_vkGetEncodedVideoSessionParametersKHR fp_vkGetEncodedVideoSessionParametersKHR = nullptr; #else - void * fp_vkGetEncodedVideoSessionParametersKHR{}; + void* fp_vkGetEncodedVideoSessionParametersKHR{}; #endif #if (defined(VK_KHR_video_queue)) PFN_vkDestroyVideoSessionParametersKHR fp_vkDestroyVideoSessionParametersKHR = nullptr; #else - void * fp_vkDestroyVideoSessionParametersKHR{}; + void* fp_vkDestroyVideoSessionParametersKHR{}; #endif #if (defined(VK_KHR_video_queue)) PFN_vkGetVideoSessionMemoryRequirementsKHR fp_vkGetVideoSessionMemoryRequirementsKHR = nullptr; #else - void * fp_vkGetVideoSessionMemoryRequirementsKHR{}; + void* fp_vkGetVideoSessionMemoryRequirementsKHR{}; #endif #if (defined(VK_KHR_video_queue)) PFN_vkBindVideoSessionMemoryKHR fp_vkBindVideoSessionMemoryKHR = nullptr; #else - void * fp_vkBindVideoSessionMemoryKHR{}; + void* fp_vkBindVideoSessionMemoryKHR{}; #endif #if (defined(VK_KHR_video_decode_queue)) PFN_vkCmdDecodeVideoKHR fp_vkCmdDecodeVideoKHR = nullptr; #else - void * fp_vkCmdDecodeVideoKHR{}; + void* fp_vkCmdDecodeVideoKHR{}; #endif #if (defined(VK_KHR_video_queue)) PFN_vkCmdBeginVideoCodingKHR fp_vkCmdBeginVideoCodingKHR = nullptr; #else - void * fp_vkCmdBeginVideoCodingKHR{}; + void* fp_vkCmdBeginVideoCodingKHR{}; #endif #if (defined(VK_KHR_video_queue)) PFN_vkCmdControlVideoCodingKHR fp_vkCmdControlVideoCodingKHR = nullptr; #else - void * fp_vkCmdControlVideoCodingKHR{}; + void* fp_vkCmdControlVideoCodingKHR{}; #endif #if (defined(VK_KHR_video_queue)) PFN_vkCmdEndVideoCodingKHR fp_vkCmdEndVideoCodingKHR = nullptr; #else - void * fp_vkCmdEndVideoCodingKHR{}; + void* fp_vkCmdEndVideoCodingKHR{}; #endif #if (defined(VK_KHR_video_encode_queue)) PFN_vkCmdEncodeVideoKHR fp_vkCmdEncodeVideoKHR = nullptr; #else - void * fp_vkCmdEncodeVideoKHR{}; + void* fp_vkCmdEncodeVideoKHR{}; #endif #if (defined(VK_NV_memory_decompression)) PFN_vkCmdDecompressMemoryNV fp_vkCmdDecompressMemoryNV = nullptr; #else - void * fp_vkCmdDecompressMemoryNV{}; + void* fp_vkCmdDecompressMemoryNV{}; #endif #if (defined(VK_NV_memory_decompression)) PFN_vkCmdDecompressMemoryIndirectCountNV fp_vkCmdDecompressMemoryIndirectCountNV = nullptr; #else - void * fp_vkCmdDecompressMemoryIndirectCountNV{}; + void* fp_vkCmdDecompressMemoryIndirectCountNV{}; #endif #if (defined(VK_EXT_descriptor_buffer)) PFN_vkGetDescriptorSetLayoutSizeEXT fp_vkGetDescriptorSetLayoutSizeEXT = nullptr; #else - void * fp_vkGetDescriptorSetLayoutSizeEXT{}; + void* fp_vkGetDescriptorSetLayoutSizeEXT{}; #endif #if (defined(VK_EXT_descriptor_buffer)) PFN_vkGetDescriptorSetLayoutBindingOffsetEXT fp_vkGetDescriptorSetLayoutBindingOffsetEXT = nullptr; #else - void * fp_vkGetDescriptorSetLayoutBindingOffsetEXT{}; + void* fp_vkGetDescriptorSetLayoutBindingOffsetEXT{}; #endif #if (defined(VK_EXT_descriptor_buffer)) PFN_vkGetDescriptorEXT fp_vkGetDescriptorEXT = nullptr; #else - void * fp_vkGetDescriptorEXT{}; + void* fp_vkGetDescriptorEXT{}; #endif #if (defined(VK_EXT_descriptor_buffer)) PFN_vkCmdBindDescriptorBuffersEXT fp_vkCmdBindDescriptorBuffersEXT = nullptr; #else - void * fp_vkCmdBindDescriptorBuffersEXT{}; + void* fp_vkCmdBindDescriptorBuffersEXT{}; #endif #if (defined(VK_EXT_descriptor_buffer)) PFN_vkCmdSetDescriptorBufferOffsetsEXT fp_vkCmdSetDescriptorBufferOffsetsEXT = nullptr; #else - void * fp_vkCmdSetDescriptorBufferOffsetsEXT{}; + void* fp_vkCmdSetDescriptorBufferOffsetsEXT{}; #endif #if (defined(VK_EXT_descriptor_buffer)) PFN_vkCmdBindDescriptorBufferEmbeddedSamplersEXT fp_vkCmdBindDescriptorBufferEmbeddedSamplersEXT = nullptr; #else - void * fp_vkCmdBindDescriptorBufferEmbeddedSamplersEXT{}; + void* fp_vkCmdBindDescriptorBufferEmbeddedSamplersEXT{}; #endif #if (defined(VK_EXT_descriptor_buffer)) PFN_vkGetBufferOpaqueCaptureDescriptorDataEXT fp_vkGetBufferOpaqueCaptureDescriptorDataEXT = nullptr; #else - void * fp_vkGetBufferOpaqueCaptureDescriptorDataEXT{}; + void* fp_vkGetBufferOpaqueCaptureDescriptorDataEXT{}; #endif #if (defined(VK_EXT_descriptor_buffer)) PFN_vkGetImageOpaqueCaptureDescriptorDataEXT fp_vkGetImageOpaqueCaptureDescriptorDataEXT = nullptr; #else - void * fp_vkGetImageOpaqueCaptureDescriptorDataEXT{}; + void* fp_vkGetImageOpaqueCaptureDescriptorDataEXT{}; #endif #if (defined(VK_EXT_descriptor_buffer)) PFN_vkGetImageViewOpaqueCaptureDescriptorDataEXT fp_vkGetImageViewOpaqueCaptureDescriptorDataEXT = nullptr; #else - void * fp_vkGetImageViewOpaqueCaptureDescriptorDataEXT{}; + void* fp_vkGetImageViewOpaqueCaptureDescriptorDataEXT{}; #endif #if (defined(VK_EXT_descriptor_buffer)) PFN_vkGetSamplerOpaqueCaptureDescriptorDataEXT fp_vkGetSamplerOpaqueCaptureDescriptorDataEXT = nullptr; #else - void * fp_vkGetSamplerOpaqueCaptureDescriptorDataEXT{}; + void* fp_vkGetSamplerOpaqueCaptureDescriptorDataEXT{}; #endif #if (defined(VK_EXT_descriptor_buffer)) - PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT fp_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = nullptr; + PFN_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT + fp_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT = nullptr; #else - void * fp_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT{}; + void* fp_vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT{}; #endif #if (defined(VK_EXT_pageable_device_local_memory)) PFN_vkSetDeviceMemoryPriorityEXT fp_vkSetDeviceMemoryPriorityEXT = nullptr; #else - void * fp_vkSetDeviceMemoryPriorityEXT{}; + void* fp_vkSetDeviceMemoryPriorityEXT{}; #endif #if (defined(VK_KHR_present_wait)) PFN_vkWaitForPresentKHR fp_vkWaitForPresentKHR = nullptr; #else - void * fp_vkWaitForPresentKHR{}; + void* fp_vkWaitForPresentKHR{}; #endif #if (defined(VK_FUCHSIA_buffer_collection)) PFN_vkCreateBufferCollectionFUCHSIA fp_vkCreateBufferCollectionFUCHSIA = nullptr; #else - void * fp_vkCreateBufferCollectionFUCHSIA{}; + void* fp_vkCreateBufferCollectionFUCHSIA{}; #endif #if (defined(VK_FUCHSIA_buffer_collection)) PFN_vkSetBufferCollectionBufferConstraintsFUCHSIA fp_vkSetBufferCollectionBufferConstraintsFUCHSIA = nullptr; #else - void * fp_vkSetBufferCollectionBufferConstraintsFUCHSIA{}; + void* fp_vkSetBufferCollectionBufferConstraintsFUCHSIA{}; #endif #if (defined(VK_FUCHSIA_buffer_collection)) PFN_vkSetBufferCollectionImageConstraintsFUCHSIA fp_vkSetBufferCollectionImageConstraintsFUCHSIA = nullptr; #else - void * fp_vkSetBufferCollectionImageConstraintsFUCHSIA{}; + void* fp_vkSetBufferCollectionImageConstraintsFUCHSIA{}; #endif #if (defined(VK_FUCHSIA_buffer_collection)) PFN_vkDestroyBufferCollectionFUCHSIA fp_vkDestroyBufferCollectionFUCHSIA = nullptr; #else - void * fp_vkDestroyBufferCollectionFUCHSIA{}; + void* fp_vkDestroyBufferCollectionFUCHSIA{}; #endif #if (defined(VK_FUCHSIA_buffer_collection)) PFN_vkGetBufferCollectionPropertiesFUCHSIA fp_vkGetBufferCollectionPropertiesFUCHSIA = nullptr; #else - void * fp_vkGetBufferCollectionPropertiesFUCHSIA{}; + void* fp_vkGetBufferCollectionPropertiesFUCHSIA{}; #endif #if (defined(VK_NV_cuda_kernel_launch)) PFN_vkCreateCudaModuleNV fp_vkCreateCudaModuleNV = nullptr; #else - void * fp_vkCreateCudaModuleNV{}; + void* fp_vkCreateCudaModuleNV{}; #endif #if (defined(VK_NV_cuda_kernel_launch)) PFN_vkGetCudaModuleCacheNV fp_vkGetCudaModuleCacheNV = nullptr; #else - void * fp_vkGetCudaModuleCacheNV{}; + void* fp_vkGetCudaModuleCacheNV{}; #endif #if (defined(VK_NV_cuda_kernel_launch)) PFN_vkCreateCudaFunctionNV fp_vkCreateCudaFunctionNV = nullptr; #else - void * fp_vkCreateCudaFunctionNV{}; + void* fp_vkCreateCudaFunctionNV{}; #endif #if (defined(VK_NV_cuda_kernel_launch)) PFN_vkDestroyCudaModuleNV fp_vkDestroyCudaModuleNV = nullptr; #else - void * fp_vkDestroyCudaModuleNV{}; + void* fp_vkDestroyCudaModuleNV{}; #endif #if (defined(VK_NV_cuda_kernel_launch)) PFN_vkDestroyCudaFunctionNV fp_vkDestroyCudaFunctionNV = nullptr; #else - void * fp_vkDestroyCudaFunctionNV{}; + void* fp_vkDestroyCudaFunctionNV{}; #endif #if (defined(VK_NV_cuda_kernel_launch)) PFN_vkCmdCudaLaunchKernelNV fp_vkCmdCudaLaunchKernelNV = nullptr; #else - void * fp_vkCmdCudaLaunchKernelNV{}; + void* fp_vkCmdCudaLaunchKernelNV{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdBeginRendering fp_vkCmdBeginRendering = nullptr; #else - void * fp_vkCmdBeginRendering{}; + void* fp_vkCmdBeginRendering{}; #endif #if (defined(VK_VERSION_1_3)) PFN_vkCmdEndRendering fp_vkCmdEndRendering = nullptr; #else - void * fp_vkCmdEndRendering{}; + void* fp_vkCmdEndRendering{}; #endif #if (defined(VK_VALVE_descriptor_set_host_mapping)) PFN_vkGetDescriptorSetLayoutHostMappingInfoVALVE fp_vkGetDescriptorSetLayoutHostMappingInfoVALVE = nullptr; #else - void * fp_vkGetDescriptorSetLayoutHostMappingInfoVALVE{}; + void* fp_vkGetDescriptorSetLayoutHostMappingInfoVALVE{}; #endif #if (defined(VK_VALVE_descriptor_set_host_mapping)) PFN_vkGetDescriptorSetHostMappingVALVE fp_vkGetDescriptorSetHostMappingVALVE = nullptr; #else - void * fp_vkGetDescriptorSetHostMappingVALVE{}; + void* fp_vkGetDescriptorSetHostMappingVALVE{}; #endif #if (defined(VK_EXT_opacity_micromap)) PFN_vkCreateMicromapEXT fp_vkCreateMicromapEXT = nullptr; #else - void * fp_vkCreateMicromapEXT{}; + void* fp_vkCreateMicromapEXT{}; #endif #if (defined(VK_EXT_opacity_micromap)) PFN_vkCmdBuildMicromapsEXT fp_vkCmdBuildMicromapsEXT = nullptr; #else - void * fp_vkCmdBuildMicromapsEXT{}; + void* fp_vkCmdBuildMicromapsEXT{}; #endif #if (defined(VK_EXT_opacity_micromap)) PFN_vkBuildMicromapsEXT fp_vkBuildMicromapsEXT = nullptr; #else - void * fp_vkBuildMicromapsEXT{}; + void* fp_vkBuildMicromapsEXT{}; #endif #if (defined(VK_EXT_opacity_micromap)) PFN_vkDestroyMicromapEXT fp_vkDestroyMicromapEXT = nullptr; #else - void * fp_vkDestroyMicromapEXT{}; + void* fp_vkDestroyMicromapEXT{}; #endif #if (defined(VK_EXT_opacity_micromap)) PFN_vkCmdCopyMicromapEXT fp_vkCmdCopyMicromapEXT = nullptr; #else - void * fp_vkCmdCopyMicromapEXT{}; + void* fp_vkCmdCopyMicromapEXT{}; #endif #if (defined(VK_EXT_opacity_micromap)) PFN_vkCopyMicromapEXT fp_vkCopyMicromapEXT = nullptr; #else - void * fp_vkCopyMicromapEXT{}; + void* fp_vkCopyMicromapEXT{}; #endif #if (defined(VK_EXT_opacity_micromap)) PFN_vkCmdCopyMicromapToMemoryEXT fp_vkCmdCopyMicromapToMemoryEXT = nullptr; #else - void * fp_vkCmdCopyMicromapToMemoryEXT{}; + void* fp_vkCmdCopyMicromapToMemoryEXT{}; #endif #if (defined(VK_EXT_opacity_micromap)) PFN_vkCopyMicromapToMemoryEXT fp_vkCopyMicromapToMemoryEXT = nullptr; #else - void * fp_vkCopyMicromapToMemoryEXT{}; + void* fp_vkCopyMicromapToMemoryEXT{}; #endif #if (defined(VK_EXT_opacity_micromap)) PFN_vkCmdCopyMemoryToMicromapEXT fp_vkCmdCopyMemoryToMicromapEXT = nullptr; #else - void * fp_vkCmdCopyMemoryToMicromapEXT{}; + void* fp_vkCmdCopyMemoryToMicromapEXT{}; #endif #if (defined(VK_EXT_opacity_micromap)) PFN_vkCopyMemoryToMicromapEXT fp_vkCopyMemoryToMicromapEXT = nullptr; #else - void * fp_vkCopyMemoryToMicromapEXT{}; + void* fp_vkCopyMemoryToMicromapEXT{}; #endif #if (defined(VK_EXT_opacity_micromap)) PFN_vkCmdWriteMicromapsPropertiesEXT fp_vkCmdWriteMicromapsPropertiesEXT = nullptr; #else - void * fp_vkCmdWriteMicromapsPropertiesEXT{}; + void* fp_vkCmdWriteMicromapsPropertiesEXT{}; #endif #if (defined(VK_EXT_opacity_micromap)) PFN_vkWriteMicromapsPropertiesEXT fp_vkWriteMicromapsPropertiesEXT = nullptr; #else - void * fp_vkWriteMicromapsPropertiesEXT{}; + void* fp_vkWriteMicromapsPropertiesEXT{}; #endif #if (defined(VK_EXT_opacity_micromap)) PFN_vkGetDeviceMicromapCompatibilityEXT fp_vkGetDeviceMicromapCompatibilityEXT = nullptr; #else - void * fp_vkGetDeviceMicromapCompatibilityEXT{}; + void* fp_vkGetDeviceMicromapCompatibilityEXT{}; #endif #if (defined(VK_EXT_opacity_micromap)) PFN_vkGetMicromapBuildSizesEXT fp_vkGetMicromapBuildSizesEXT = nullptr; #else - void * fp_vkGetMicromapBuildSizesEXT{}; + void* fp_vkGetMicromapBuildSizesEXT{}; #endif #if (defined(VK_EXT_shader_module_identifier)) PFN_vkGetShaderModuleIdentifierEXT fp_vkGetShaderModuleIdentifierEXT = nullptr; #else - void * fp_vkGetShaderModuleIdentifierEXT{}; + void* fp_vkGetShaderModuleIdentifierEXT{}; #endif #if (defined(VK_EXT_shader_module_identifier)) PFN_vkGetShaderModuleCreateInfoIdentifierEXT fp_vkGetShaderModuleCreateInfoIdentifierEXT = nullptr; #else - void * fp_vkGetShaderModuleCreateInfoIdentifierEXT{}; + void* fp_vkGetShaderModuleCreateInfoIdentifierEXT{}; #endif #if (defined(VK_KHR_maintenance5)) PFN_vkGetImageSubresourceLayout2KHR fp_vkGetImageSubresourceLayout2KHR = nullptr; #else - void * fp_vkGetImageSubresourceLayout2KHR{}; + void* fp_vkGetImageSubresourceLayout2KHR{}; #endif #if (defined(VK_EXT_pipeline_properties)) PFN_vkGetPipelinePropertiesEXT fp_vkGetPipelinePropertiesEXT = nullptr; #else - void * fp_vkGetPipelinePropertiesEXT{}; + void* fp_vkGetPipelinePropertiesEXT{}; #endif #if (defined(VK_EXT_metal_objects)) PFN_vkExportMetalObjectsEXT fp_vkExportMetalObjectsEXT = nullptr; #else - void * fp_vkExportMetalObjectsEXT{}; + void* fp_vkExportMetalObjectsEXT{}; #endif #if (defined(VK_QCOM_tile_properties)) PFN_vkGetFramebufferTilePropertiesQCOM fp_vkGetFramebufferTilePropertiesQCOM = nullptr; #else - void * fp_vkGetFramebufferTilePropertiesQCOM{}; + void* fp_vkGetFramebufferTilePropertiesQCOM{}; #endif #if (defined(VK_QCOM_tile_properties)) PFN_vkGetDynamicRenderingTilePropertiesQCOM fp_vkGetDynamicRenderingTilePropertiesQCOM = nullptr; #else - void * fp_vkGetDynamicRenderingTilePropertiesQCOM{}; + void* fp_vkGetDynamicRenderingTilePropertiesQCOM{}; #endif #if (defined(VK_NV_optical_flow)) PFN_vkCreateOpticalFlowSessionNV fp_vkCreateOpticalFlowSessionNV = nullptr; #else - void * fp_vkCreateOpticalFlowSessionNV{}; + void* fp_vkCreateOpticalFlowSessionNV{}; #endif #if (defined(VK_NV_optical_flow)) PFN_vkDestroyOpticalFlowSessionNV fp_vkDestroyOpticalFlowSessionNV = nullptr; #else - void * fp_vkDestroyOpticalFlowSessionNV{}; + void* fp_vkDestroyOpticalFlowSessionNV{}; #endif #if (defined(VK_NV_optical_flow)) PFN_vkBindOpticalFlowSessionImageNV fp_vkBindOpticalFlowSessionImageNV = nullptr; #else - void * fp_vkBindOpticalFlowSessionImageNV{}; + void* fp_vkBindOpticalFlowSessionImageNV{}; #endif #if (defined(VK_NV_optical_flow)) PFN_vkCmdOpticalFlowExecuteNV fp_vkCmdOpticalFlowExecuteNV = nullptr; #else - void * fp_vkCmdOpticalFlowExecuteNV{}; + void* fp_vkCmdOpticalFlowExecuteNV{}; #endif #if (defined(VK_EXT_device_fault)) PFN_vkGetDeviceFaultInfoEXT fp_vkGetDeviceFaultInfoEXT = nullptr; #else - void * fp_vkGetDeviceFaultInfoEXT{}; + void* fp_vkGetDeviceFaultInfoEXT{}; #endif #if (defined(VK_EXT_depth_bias_control)) PFN_vkCmdSetDepthBias2EXT fp_vkCmdSetDepthBias2EXT = nullptr; #else - void * fp_vkCmdSetDepthBias2EXT{}; + void* fp_vkCmdSetDepthBias2EXT{}; #endif #if (defined(VK_EXT_swapchain_maintenance1)) PFN_vkReleaseSwapchainImagesEXT fp_vkReleaseSwapchainImagesEXT = nullptr; #else - void * fp_vkReleaseSwapchainImagesEXT{}; + void* fp_vkReleaseSwapchainImagesEXT{}; #endif #if (defined(VK_KHR_maintenance5)) PFN_vkGetDeviceImageSubresourceLayoutKHR fp_vkGetDeviceImageSubresourceLayoutKHR = nullptr; #else - void * fp_vkGetDeviceImageSubresourceLayoutKHR{}; + void* fp_vkGetDeviceImageSubresourceLayoutKHR{}; #endif #if (defined(VK_KHR_map_memory2)) PFN_vkMapMemory2KHR fp_vkMapMemory2KHR = nullptr; #else - void * fp_vkMapMemory2KHR{}; + void* fp_vkMapMemory2KHR{}; #endif #if (defined(VK_KHR_map_memory2)) PFN_vkUnmapMemory2KHR fp_vkUnmapMemory2KHR = nullptr; #else - void * fp_vkUnmapMemory2KHR{}; + void* fp_vkUnmapMemory2KHR{}; #endif #if (defined(VK_EXT_shader_object)) PFN_vkCreateShadersEXT fp_vkCreateShadersEXT = nullptr; #else - void * fp_vkCreateShadersEXT{}; + void* fp_vkCreateShadersEXT{}; #endif #if (defined(VK_EXT_shader_object)) PFN_vkDestroyShaderEXT fp_vkDestroyShaderEXT = nullptr; #else - void * fp_vkDestroyShaderEXT{}; + void* fp_vkDestroyShaderEXT{}; #endif #if (defined(VK_EXT_shader_object)) PFN_vkGetShaderBinaryDataEXT fp_vkGetShaderBinaryDataEXT = nullptr; #else - void * fp_vkGetShaderBinaryDataEXT{}; + void* fp_vkGetShaderBinaryDataEXT{}; #endif #if (defined(VK_EXT_shader_object)) PFN_vkCmdBindShadersEXT fp_vkCmdBindShadersEXT = nullptr; #else - void * fp_vkCmdBindShadersEXT{}; + void* fp_vkCmdBindShadersEXT{}; #endif #if (defined(VK_QNX_external_memory_screen_buffer)) PFN_vkGetScreenBufferPropertiesQNX fp_vkGetScreenBufferPropertiesQNX = nullptr; #else - void * fp_vkGetScreenBufferPropertiesQNX{}; + void* fp_vkGetScreenBufferPropertiesQNX{}; #endif #if (defined(VK_AMDX_shader_enqueue)) PFN_vkGetExecutionGraphPipelineScratchSizeAMDX fp_vkGetExecutionGraphPipelineScratchSizeAMDX = nullptr; #else - void * fp_vkGetExecutionGraphPipelineScratchSizeAMDX{}; + void* fp_vkGetExecutionGraphPipelineScratchSizeAMDX{}; #endif #if (defined(VK_AMDX_shader_enqueue)) PFN_vkGetExecutionGraphPipelineNodeIndexAMDX fp_vkGetExecutionGraphPipelineNodeIndexAMDX = nullptr; #else - void * fp_vkGetExecutionGraphPipelineNodeIndexAMDX{}; + void* fp_vkGetExecutionGraphPipelineNodeIndexAMDX{}; #endif #if (defined(VK_AMDX_shader_enqueue)) PFN_vkCreateExecutionGraphPipelinesAMDX fp_vkCreateExecutionGraphPipelinesAMDX = nullptr; #else - void * fp_vkCreateExecutionGraphPipelinesAMDX{}; + void* fp_vkCreateExecutionGraphPipelinesAMDX{}; #endif #if ((defined(VK_AMDX_shader_enqueue))) && VK_HEADER_VERSION >= 298 PFN_vkCmdInitializeGraphScratchMemoryAMDX fp_vkCmdInitializeGraphScratchMemoryAMDX = nullptr; #else - void * fp_vkCmdInitializeGraphScratchMemoryAMDX{}; + void* fp_vkCmdInitializeGraphScratchMemoryAMDX{}; #endif #if ((defined(VK_AMDX_shader_enqueue))) && VK_HEADER_VERSION >= 298 PFN_vkCmdDispatchGraphAMDX fp_vkCmdDispatchGraphAMDX = nullptr; #else - void * fp_vkCmdDispatchGraphAMDX{}; + void* fp_vkCmdDispatchGraphAMDX{}; #endif #if ((defined(VK_AMDX_shader_enqueue))) && VK_HEADER_VERSION >= 298 PFN_vkCmdDispatchGraphIndirectAMDX fp_vkCmdDispatchGraphIndirectAMDX = nullptr; #else - void * fp_vkCmdDispatchGraphIndirectAMDX{}; + void* fp_vkCmdDispatchGraphIndirectAMDX{}; #endif #if ((defined(VK_AMDX_shader_enqueue))) && VK_HEADER_VERSION >= 298 PFN_vkCmdDispatchGraphIndirectCountAMDX fp_vkCmdDispatchGraphIndirectCountAMDX = nullptr; #else - void * fp_vkCmdDispatchGraphIndirectCountAMDX{}; + void* fp_vkCmdDispatchGraphIndirectCountAMDX{}; #endif #if (defined(VK_KHR_maintenance6)) PFN_vkCmdBindDescriptorSets2KHR fp_vkCmdBindDescriptorSets2KHR = nullptr; #else - void * fp_vkCmdBindDescriptorSets2KHR{}; + void* fp_vkCmdBindDescriptorSets2KHR{}; #endif #if (defined(VK_KHR_maintenance6)) PFN_vkCmdPushConstants2KHR fp_vkCmdPushConstants2KHR = nullptr; #else - void * fp_vkCmdPushConstants2KHR{}; + void* fp_vkCmdPushConstants2KHR{}; #endif #if (defined(VK_KHR_maintenance6)) PFN_vkCmdPushDescriptorSet2KHR fp_vkCmdPushDescriptorSet2KHR = nullptr; #else - void * fp_vkCmdPushDescriptorSet2KHR{}; + void* fp_vkCmdPushDescriptorSet2KHR{}; #endif #if (defined(VK_KHR_maintenance6)) PFN_vkCmdPushDescriptorSetWithTemplate2KHR fp_vkCmdPushDescriptorSetWithTemplate2KHR = nullptr; #else - void * fp_vkCmdPushDescriptorSetWithTemplate2KHR{}; + void* fp_vkCmdPushDescriptorSetWithTemplate2KHR{}; #endif #if (defined(VK_KHR_maintenance6)) PFN_vkCmdSetDescriptorBufferOffsets2EXT fp_vkCmdSetDescriptorBufferOffsets2EXT = nullptr; #else - void * fp_vkCmdSetDescriptorBufferOffsets2EXT{}; + void* fp_vkCmdSetDescriptorBufferOffsets2EXT{}; #endif #if (defined(VK_KHR_maintenance6)) PFN_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT fp_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT = nullptr; #else - void * fp_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT{}; + void* fp_vkCmdBindDescriptorBufferEmbeddedSamplers2EXT{}; #endif #if (defined(VK_NV_low_latency2)) PFN_vkSetLatencySleepModeNV fp_vkSetLatencySleepModeNV = nullptr; #else - void * fp_vkSetLatencySleepModeNV{}; + void* fp_vkSetLatencySleepModeNV{}; #endif #if (defined(VK_NV_low_latency2)) PFN_vkLatencySleepNV fp_vkLatencySleepNV = nullptr; #else - void * fp_vkLatencySleepNV{}; + void* fp_vkLatencySleepNV{}; #endif #if (defined(VK_NV_low_latency2)) PFN_vkSetLatencyMarkerNV fp_vkSetLatencyMarkerNV = nullptr; #else - void * fp_vkSetLatencyMarkerNV{}; + void* fp_vkSetLatencyMarkerNV{}; #endif #if ((defined(VK_NV_low_latency2))) && VK_HEADER_VERSION >= 271 PFN_vkGetLatencyTimingsNV fp_vkGetLatencyTimingsNV = nullptr; #else - void * fp_vkGetLatencyTimingsNV{}; + void* fp_vkGetLatencyTimingsNV{}; #endif #if (defined(VK_NV_low_latency2)) PFN_vkQueueNotifyOutOfBandNV fp_vkQueueNotifyOutOfBandNV = nullptr; #else - void * fp_vkQueueNotifyOutOfBandNV{}; + void* fp_vkQueueNotifyOutOfBandNV{}; #endif #if (defined(VK_KHR_dynamic_rendering_local_read)) PFN_vkCmdSetRenderingAttachmentLocationsKHR fp_vkCmdSetRenderingAttachmentLocationsKHR = nullptr; #else - void * fp_vkCmdSetRenderingAttachmentLocationsKHR{}; + void* fp_vkCmdSetRenderingAttachmentLocationsKHR{}; #endif #if (defined(VK_KHR_dynamic_rendering_local_read)) PFN_vkCmdSetRenderingInputAttachmentIndicesKHR fp_vkCmdSetRenderingInputAttachmentIndicesKHR = nullptr; #else - void * fp_vkCmdSetRenderingInputAttachmentIndicesKHR{}; + void* fp_vkCmdSetRenderingInputAttachmentIndicesKHR{}; #endif #if (defined(VK_EXT_shader_object)) || (defined(VK_EXT_depth_clamp_control)) PFN_vkCmdSetDepthClampRangeEXT fp_vkCmdSetDepthClampRangeEXT = nullptr; #else - void * fp_vkCmdSetDepthClampRangeEXT{}; + void* fp_vkCmdSetDepthClampRangeEXT{}; #endif #if (defined(VK_EXT_host_query_reset)) PFN_vkResetQueryPoolEXT fp_vkResetQueryPoolEXT = nullptr; #else - void * fp_vkResetQueryPoolEXT{}; + void* fp_vkResetQueryPoolEXT{}; #endif #if (defined(VK_KHR_maintenance1)) PFN_vkTrimCommandPoolKHR fp_vkTrimCommandPoolKHR = nullptr; #else - void * fp_vkTrimCommandPoolKHR{}; + void* fp_vkTrimCommandPoolKHR{}; #endif #if (defined(VK_KHR_device_group)) PFN_vkGetDeviceGroupPeerMemoryFeaturesKHR fp_vkGetDeviceGroupPeerMemoryFeaturesKHR = nullptr; #else - void * fp_vkGetDeviceGroupPeerMemoryFeaturesKHR{}; + void* fp_vkGetDeviceGroupPeerMemoryFeaturesKHR{}; #endif #if (defined(VK_KHR_bind_memory2)) PFN_vkBindBufferMemory2KHR fp_vkBindBufferMemory2KHR = nullptr; #else - void * fp_vkBindBufferMemory2KHR{}; + void* fp_vkBindBufferMemory2KHR{}; #endif #if (defined(VK_KHR_bind_memory2)) PFN_vkBindImageMemory2KHR fp_vkBindImageMemory2KHR = nullptr; #else - void * fp_vkBindImageMemory2KHR{}; + void* fp_vkBindImageMemory2KHR{}; #endif #if (defined(VK_KHR_device_group)) PFN_vkCmdSetDeviceMaskKHR fp_vkCmdSetDeviceMaskKHR = nullptr; #else - void * fp_vkCmdSetDeviceMaskKHR{}; + void* fp_vkCmdSetDeviceMaskKHR{}; #endif #if (defined(VK_KHR_device_group)) PFN_vkCmdDispatchBaseKHR fp_vkCmdDispatchBaseKHR = nullptr; #else - void * fp_vkCmdDispatchBaseKHR{}; + void* fp_vkCmdDispatchBaseKHR{}; #endif #if (defined(VK_KHR_descriptor_update_template)) PFN_vkCreateDescriptorUpdateTemplateKHR fp_vkCreateDescriptorUpdateTemplateKHR = nullptr; #else - void * fp_vkCreateDescriptorUpdateTemplateKHR{}; + void* fp_vkCreateDescriptorUpdateTemplateKHR{}; #endif #if (defined(VK_KHR_descriptor_update_template)) PFN_vkDestroyDescriptorUpdateTemplateKHR fp_vkDestroyDescriptorUpdateTemplateKHR = nullptr; #else - void * fp_vkDestroyDescriptorUpdateTemplateKHR{}; + void* fp_vkDestroyDescriptorUpdateTemplateKHR{}; #endif #if (defined(VK_KHR_descriptor_update_template)) PFN_vkUpdateDescriptorSetWithTemplateKHR fp_vkUpdateDescriptorSetWithTemplateKHR = nullptr; #else - void * fp_vkUpdateDescriptorSetWithTemplateKHR{}; + void* fp_vkUpdateDescriptorSetWithTemplateKHR{}; #endif #if (defined(VK_KHR_get_memory_requirements2)) PFN_vkGetBufferMemoryRequirements2KHR fp_vkGetBufferMemoryRequirements2KHR = nullptr; #else - void * fp_vkGetBufferMemoryRequirements2KHR{}; + void* fp_vkGetBufferMemoryRequirements2KHR{}; #endif #if (defined(VK_KHR_get_memory_requirements2)) PFN_vkGetImageMemoryRequirements2KHR fp_vkGetImageMemoryRequirements2KHR = nullptr; #else - void * fp_vkGetImageMemoryRequirements2KHR{}; + void* fp_vkGetImageMemoryRequirements2KHR{}; #endif #if (defined(VK_KHR_get_memory_requirements2)) PFN_vkGetImageSparseMemoryRequirements2KHR fp_vkGetImageSparseMemoryRequirements2KHR = nullptr; #else - void * fp_vkGetImageSparseMemoryRequirements2KHR{}; + void* fp_vkGetImageSparseMemoryRequirements2KHR{}; #endif #if (defined(VK_KHR_maintenance4)) PFN_vkGetDeviceBufferMemoryRequirementsKHR fp_vkGetDeviceBufferMemoryRequirementsKHR = nullptr; #else - void * fp_vkGetDeviceBufferMemoryRequirementsKHR{}; + void* fp_vkGetDeviceBufferMemoryRequirementsKHR{}; #endif #if (defined(VK_KHR_maintenance4)) PFN_vkGetDeviceImageMemoryRequirementsKHR fp_vkGetDeviceImageMemoryRequirementsKHR = nullptr; #else - void * fp_vkGetDeviceImageMemoryRequirementsKHR{}; + void* fp_vkGetDeviceImageMemoryRequirementsKHR{}; #endif #if (defined(VK_KHR_maintenance4)) PFN_vkGetDeviceImageSparseMemoryRequirementsKHR fp_vkGetDeviceImageSparseMemoryRequirementsKHR = nullptr; #else - void * fp_vkGetDeviceImageSparseMemoryRequirementsKHR{}; + void* fp_vkGetDeviceImageSparseMemoryRequirementsKHR{}; #endif #if (defined(VK_KHR_sampler_ycbcr_conversion)) PFN_vkCreateSamplerYcbcrConversionKHR fp_vkCreateSamplerYcbcrConversionKHR = nullptr; #else - void * fp_vkCreateSamplerYcbcrConversionKHR{}; + void* fp_vkCreateSamplerYcbcrConversionKHR{}; #endif #if (defined(VK_KHR_sampler_ycbcr_conversion)) PFN_vkDestroySamplerYcbcrConversionKHR fp_vkDestroySamplerYcbcrConversionKHR = nullptr; #else - void * fp_vkDestroySamplerYcbcrConversionKHR{}; + void* fp_vkDestroySamplerYcbcrConversionKHR{}; #endif #if (defined(VK_KHR_maintenance3)) PFN_vkGetDescriptorSetLayoutSupportKHR fp_vkGetDescriptorSetLayoutSupportKHR = nullptr; #else - void * fp_vkGetDescriptorSetLayoutSupportKHR{}; + void* fp_vkGetDescriptorSetLayoutSupportKHR{}; #endif #if (defined(VK_EXT_calibrated_timestamps)) PFN_vkGetCalibratedTimestampsEXT fp_vkGetCalibratedTimestampsEXT = nullptr; #else - void * fp_vkGetCalibratedTimestampsEXT{}; + void* fp_vkGetCalibratedTimestampsEXT{}; #endif #if (defined(VK_KHR_create_renderpass2)) PFN_vkCreateRenderPass2KHR fp_vkCreateRenderPass2KHR = nullptr; #else - void * fp_vkCreateRenderPass2KHR{}; + void* fp_vkCreateRenderPass2KHR{}; #endif #if (defined(VK_KHR_create_renderpass2)) PFN_vkCmdBeginRenderPass2KHR fp_vkCmdBeginRenderPass2KHR = nullptr; #else - void * fp_vkCmdBeginRenderPass2KHR{}; + void* fp_vkCmdBeginRenderPass2KHR{}; #endif #if (defined(VK_KHR_create_renderpass2)) PFN_vkCmdNextSubpass2KHR fp_vkCmdNextSubpass2KHR = nullptr; #else - void * fp_vkCmdNextSubpass2KHR{}; + void* fp_vkCmdNextSubpass2KHR{}; #endif #if (defined(VK_KHR_create_renderpass2)) PFN_vkCmdEndRenderPass2KHR fp_vkCmdEndRenderPass2KHR = nullptr; #else - void * fp_vkCmdEndRenderPass2KHR{}; + void* fp_vkCmdEndRenderPass2KHR{}; #endif #if (defined(VK_KHR_timeline_semaphore)) PFN_vkGetSemaphoreCounterValueKHR fp_vkGetSemaphoreCounterValueKHR = nullptr; #else - void * fp_vkGetSemaphoreCounterValueKHR{}; + void* fp_vkGetSemaphoreCounterValueKHR{}; #endif #if (defined(VK_KHR_timeline_semaphore)) PFN_vkWaitSemaphoresKHR fp_vkWaitSemaphoresKHR = nullptr; #else - void * fp_vkWaitSemaphoresKHR{}; + void* fp_vkWaitSemaphoresKHR{}; #endif #if (defined(VK_KHR_timeline_semaphore)) PFN_vkSignalSemaphoreKHR fp_vkSignalSemaphoreKHR = nullptr; #else - void * fp_vkSignalSemaphoreKHR{}; + void* fp_vkSignalSemaphoreKHR{}; #endif #if (defined(VK_AMD_draw_indirect_count)) PFN_vkCmdDrawIndirectCountAMD fp_vkCmdDrawIndirectCountAMD = nullptr; #else - void * fp_vkCmdDrawIndirectCountAMD{}; + void* fp_vkCmdDrawIndirectCountAMD{}; #endif #if (defined(VK_AMD_draw_indirect_count)) PFN_vkCmdDrawIndexedIndirectCountAMD fp_vkCmdDrawIndexedIndirectCountAMD = nullptr; #else - void * fp_vkCmdDrawIndexedIndirectCountAMD{}; + void* fp_vkCmdDrawIndexedIndirectCountAMD{}; #endif #if (defined(VK_NV_ray_tracing)) PFN_vkGetRayTracingShaderGroupHandlesNV fp_vkGetRayTracingShaderGroupHandlesNV = nullptr; #else - void * fp_vkGetRayTracingShaderGroupHandlesNV{}; + void* fp_vkGetRayTracingShaderGroupHandlesNV{}; #endif #if (defined(VK_KHR_buffer_device_address)) PFN_vkGetBufferOpaqueCaptureAddressKHR fp_vkGetBufferOpaqueCaptureAddressKHR = nullptr; #else - void * fp_vkGetBufferOpaqueCaptureAddressKHR{}; + void* fp_vkGetBufferOpaqueCaptureAddressKHR{}; #endif #if (defined(VK_EXT_buffer_device_address)) PFN_vkGetBufferDeviceAddressEXT fp_vkGetBufferDeviceAddressEXT = nullptr; #else - void * fp_vkGetBufferDeviceAddressEXT{}; + void* fp_vkGetBufferDeviceAddressEXT{}; #endif #if (defined(VK_KHR_buffer_device_address)) PFN_vkGetDeviceMemoryOpaqueCaptureAddressKHR fp_vkGetDeviceMemoryOpaqueCaptureAddressKHR = nullptr; #else - void * fp_vkGetDeviceMemoryOpaqueCaptureAddressKHR{}; + void* fp_vkGetDeviceMemoryOpaqueCaptureAddressKHR{}; #endif #if (defined(VK_EXT_line_rasterization)) PFN_vkCmdSetLineStippleEXT fp_vkCmdSetLineStippleEXT = nullptr; #else - void * fp_vkCmdSetLineStippleEXT{}; + void* fp_vkCmdSetLineStippleEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetCullModeEXT fp_vkCmdSetCullModeEXT = nullptr; #else - void * fp_vkCmdSetCullModeEXT{}; + void* fp_vkCmdSetCullModeEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetFrontFaceEXT fp_vkCmdSetFrontFaceEXT = nullptr; #else - void * fp_vkCmdSetFrontFaceEXT{}; + void* fp_vkCmdSetFrontFaceEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetPrimitiveTopologyEXT fp_vkCmdSetPrimitiveTopologyEXT = nullptr; #else - void * fp_vkCmdSetPrimitiveTopologyEXT{}; + void* fp_vkCmdSetPrimitiveTopologyEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetViewportWithCountEXT fp_vkCmdSetViewportWithCountEXT = nullptr; #else - void * fp_vkCmdSetViewportWithCountEXT{}; + void* fp_vkCmdSetViewportWithCountEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetScissorWithCountEXT fp_vkCmdSetScissorWithCountEXT = nullptr; #else - void * fp_vkCmdSetScissorWithCountEXT{}; + void* fp_vkCmdSetScissorWithCountEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) PFN_vkCmdBindVertexBuffers2EXT fp_vkCmdBindVertexBuffers2EXT = nullptr; #else - void * fp_vkCmdBindVertexBuffers2EXT{}; + void* fp_vkCmdBindVertexBuffers2EXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetDepthTestEnableEXT fp_vkCmdSetDepthTestEnableEXT = nullptr; #else - void * fp_vkCmdSetDepthTestEnableEXT{}; + void* fp_vkCmdSetDepthTestEnableEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetDepthWriteEnableEXT fp_vkCmdSetDepthWriteEnableEXT = nullptr; #else - void * fp_vkCmdSetDepthWriteEnableEXT{}; + void* fp_vkCmdSetDepthWriteEnableEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetDepthCompareOpEXT fp_vkCmdSetDepthCompareOpEXT = nullptr; #else - void * fp_vkCmdSetDepthCompareOpEXT{}; + void* fp_vkCmdSetDepthCompareOpEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetDepthBoundsTestEnableEXT fp_vkCmdSetDepthBoundsTestEnableEXT = nullptr; #else - void * fp_vkCmdSetDepthBoundsTestEnableEXT{}; + void* fp_vkCmdSetDepthBoundsTestEnableEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetStencilTestEnableEXT fp_vkCmdSetStencilTestEnableEXT = nullptr; #else - void * fp_vkCmdSetStencilTestEnableEXT{}; + void* fp_vkCmdSetStencilTestEnableEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetStencilOpEXT fp_vkCmdSetStencilOpEXT = nullptr; #else - void * fp_vkCmdSetStencilOpEXT{}; + void* fp_vkCmdSetStencilOpEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetRasterizerDiscardEnableEXT fp_vkCmdSetRasterizerDiscardEnableEXT = nullptr; #else - void * fp_vkCmdSetRasterizerDiscardEnableEXT{}; + void* fp_vkCmdSetRasterizerDiscardEnableEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetDepthBiasEnableEXT fp_vkCmdSetDepthBiasEnableEXT = nullptr; #else - void * fp_vkCmdSetDepthBiasEnableEXT{}; + void* fp_vkCmdSetDepthBiasEnableEXT{}; #endif #if (defined(VK_EXT_extended_dynamic_state2)) || (defined(VK_EXT_shader_object)) PFN_vkCmdSetPrimitiveRestartEnableEXT fp_vkCmdSetPrimitiveRestartEnableEXT = nullptr; #else - void * fp_vkCmdSetPrimitiveRestartEnableEXT{}; + void* fp_vkCmdSetPrimitiveRestartEnableEXT{}; #endif #if (defined(VK_EXT_private_data)) PFN_vkCreatePrivateDataSlotEXT fp_vkCreatePrivateDataSlotEXT = nullptr; #else - void * fp_vkCreatePrivateDataSlotEXT{}; + void* fp_vkCreatePrivateDataSlotEXT{}; #endif #if (defined(VK_EXT_private_data)) PFN_vkDestroyPrivateDataSlotEXT fp_vkDestroyPrivateDataSlotEXT = nullptr; #else - void * fp_vkDestroyPrivateDataSlotEXT{}; + void* fp_vkDestroyPrivateDataSlotEXT{}; #endif #if (defined(VK_EXT_private_data)) PFN_vkSetPrivateDataEXT fp_vkSetPrivateDataEXT = nullptr; #else - void * fp_vkSetPrivateDataEXT{}; + void* fp_vkSetPrivateDataEXT{}; #endif #if (defined(VK_EXT_private_data)) PFN_vkGetPrivateDataEXT fp_vkGetPrivateDataEXT = nullptr; #else - void * fp_vkGetPrivateDataEXT{}; + void* fp_vkGetPrivateDataEXT{}; #endif #if (defined(VK_KHR_copy_commands2)) PFN_vkCmdCopyBuffer2KHR fp_vkCmdCopyBuffer2KHR = nullptr; #else - void * fp_vkCmdCopyBuffer2KHR{}; + void* fp_vkCmdCopyBuffer2KHR{}; #endif #if (defined(VK_KHR_copy_commands2)) PFN_vkCmdCopyImage2KHR fp_vkCmdCopyImage2KHR = nullptr; #else - void * fp_vkCmdCopyImage2KHR{}; + void* fp_vkCmdCopyImage2KHR{}; #endif #if (defined(VK_KHR_copy_commands2)) PFN_vkCmdBlitImage2KHR fp_vkCmdBlitImage2KHR = nullptr; #else - void * fp_vkCmdBlitImage2KHR{}; + void* fp_vkCmdBlitImage2KHR{}; #endif #if (defined(VK_KHR_copy_commands2)) PFN_vkCmdCopyBufferToImage2KHR fp_vkCmdCopyBufferToImage2KHR = nullptr; #else - void * fp_vkCmdCopyBufferToImage2KHR{}; + void* fp_vkCmdCopyBufferToImage2KHR{}; #endif #if (defined(VK_KHR_copy_commands2)) PFN_vkCmdCopyImageToBuffer2KHR fp_vkCmdCopyImageToBuffer2KHR = nullptr; #else - void * fp_vkCmdCopyImageToBuffer2KHR{}; + void* fp_vkCmdCopyImageToBuffer2KHR{}; #endif #if (defined(VK_KHR_copy_commands2)) PFN_vkCmdResolveImage2KHR fp_vkCmdResolveImage2KHR = nullptr; #else - void * fp_vkCmdResolveImage2KHR{}; + void* fp_vkCmdResolveImage2KHR{}; #endif #if (defined(VK_KHR_synchronization2)) PFN_vkCmdSetEvent2KHR fp_vkCmdSetEvent2KHR = nullptr; #else - void * fp_vkCmdSetEvent2KHR{}; + void* fp_vkCmdSetEvent2KHR{}; #endif #if (defined(VK_KHR_synchronization2)) PFN_vkCmdResetEvent2KHR fp_vkCmdResetEvent2KHR = nullptr; #else - void * fp_vkCmdResetEvent2KHR{}; + void* fp_vkCmdResetEvent2KHR{}; #endif #if (defined(VK_KHR_synchronization2)) PFN_vkCmdWaitEvents2KHR fp_vkCmdWaitEvents2KHR = nullptr; #else - void * fp_vkCmdWaitEvents2KHR{}; + void* fp_vkCmdWaitEvents2KHR{}; #endif #if (defined(VK_KHR_synchronization2)) PFN_vkCmdPipelineBarrier2KHR fp_vkCmdPipelineBarrier2KHR = nullptr; #else - void * fp_vkCmdPipelineBarrier2KHR{}; + void* fp_vkCmdPipelineBarrier2KHR{}; #endif #if (defined(VK_KHR_synchronization2)) PFN_vkQueueSubmit2KHR fp_vkQueueSubmit2KHR = nullptr; #else - void * fp_vkQueueSubmit2KHR{}; + void* fp_vkQueueSubmit2KHR{}; #endif #if (defined(VK_KHR_synchronization2)) PFN_vkCmdWriteTimestamp2KHR fp_vkCmdWriteTimestamp2KHR = nullptr; #else - void * fp_vkCmdWriteTimestamp2KHR{}; + void* fp_vkCmdWriteTimestamp2KHR{}; #endif #if (defined(VK_KHR_dynamic_rendering)) PFN_vkCmdBeginRenderingKHR fp_vkCmdBeginRenderingKHR = nullptr; #else - void * fp_vkCmdBeginRenderingKHR{}; + void* fp_vkCmdBeginRenderingKHR{}; #endif #if (defined(VK_KHR_dynamic_rendering)) PFN_vkCmdEndRenderingKHR fp_vkCmdEndRenderingKHR = nullptr; #else - void * fp_vkCmdEndRenderingKHR{}; + void* fp_vkCmdEndRenderingKHR{}; #endif #if (defined(VK_EXT_host_image_copy)) || (defined(VK_EXT_image_compression_control)) PFN_vkGetImageSubresourceLayout2EXT fp_vkGetImageSubresourceLayout2EXT = nullptr; #else - void * fp_vkGetImageSubresourceLayout2EXT{}; + void* fp_vkGetImageSubresourceLayout2EXT{}; #endif - bool is_populated() const { return populated; } - VkDevice device = VK_NULL_HANDLE; + bool is_populated() const { return populated; } + VkDevice device = VK_NULL_HANDLE; PFN_vkGetDeviceProcAddr fp_vkGetDeviceProcAddr; -private: - bool populated = false; + + private: + bool populated = false; }; } // namespace vkb \ No newline at end of file diff --git a/test/test_apps/multisample-depth/app.cpp b/test/test_apps/multisample-depth/app.cpp index bd5f87fbb..1701a7fc6 100644 --- a/test/test_apps/multisample-depth/app.cpp +++ b/test/test_apps/multisample-depth/app.cpp @@ -445,7 +445,7 @@ bool App::frame(const int frame_num) { VkImageMemoryBarrier image_barriers[2]; - image_barriers[0] = {}; + image_barriers[0] = {}; image_barriers[0].sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; image_barriers[0].image = render_targets[image_index]; image_barriers[0].oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; @@ -455,7 +455,7 @@ bool App::frame(const int frame_num) image_barriers[0].subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS; image_barriers[0].srcAccessMask = VK_ACCESS_NONE; image_barriers[0].dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; - image_barriers[1] = {}; + image_barriers[1] = {}; image_barriers[1].sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; image_barriers[1].image = depth_images[image_index]; image_barriers[1].oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; @@ -464,10 +464,13 @@ bool App::frame(const int frame_num) image_barriers[1].subresourceRange.layerCount = VK_REMAINING_ARRAY_LAYERS; image_barriers[1].subresourceRange.levelCount = VK_REMAINING_MIP_LEVELS; image_barriers[1].srcAccessMask = VK_ACCESS_NONE; - image_barriers[1].dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT|VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT; + image_barriers[1].dstAccessMask = + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT; init.disp.cmdPipelineBarrier(command_buffer, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, - VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | + VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | + VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, 0, 0, nullptr, @@ -483,12 +486,9 @@ bool App::frame(const int frame_num) render_pass_info.framebuffer = this->framebuffers[image_index]; render_pass_info.renderArea.offset = { 0, 0 }; render_pass_info.renderArea.extent = init.swapchain.extent; - VkClearValue clearColors[] = { - { { { 0.0f, 0.0f, 0.0f, 1.0f } } }, - { { 1.0f } } - }; - render_pass_info.clearValueCount = 2; - render_pass_info.pClearValues = clearColors; + VkClearValue clearColors[] = { { { { 0.0f, 0.0f, 0.0f, 1.0f } } }, { { 1.0f } } }; + render_pass_info.clearValueCount = 2; + render_pass_info.pClearValues = clearColors; VkViewport viewport = {}; viewport.x = 0.0f; @@ -515,9 +515,11 @@ bool App::frame(const int frame_num) { VkMemoryBarrier memory_barrier = {}; - memory_barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER; - memory_barrier.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; - memory_barrier.dstAccessMask = VK_ACCESS_NONE; + memory_barrier.sType = VK_STRUCTURE_TYPE_MEMORY_BARRIER; + memory_barrier.srcAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | + VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | + VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; + memory_barrier.dstAccessMask = VK_ACCESS_NONE; VkImageMemoryBarrier image_barrier = {}; image_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; image_barrier.image = init.swapchain_images[image_index]; @@ -529,7 +531,9 @@ bool App::frame(const int frame_num) image_barrier.srcAccessMask = VK_ACCESS_NONE; image_barrier.dstAccessMask = VK_ACCESS_NONE; init.disp.cmdPipelineBarrier(command_buffer, - VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, + VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT | + VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | + VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, 0, 1, @@ -646,7 +650,8 @@ void App::setup() auto queue_family_index = init.device.get_queue_index(gfxrecon::test::QueueType::graphics); if (!queue_family_index) throw std::runtime_error("could not find graphics queue"); - for (auto& command_pool : command_pools) { + for (auto& command_pool : command_pools) + { command_pool = gfxrecon::test::create_command_pool(init.disp, *queue_family_index); } diff --git a/test/test_apps/triangle/app.cpp b/test/test_apps/triangle/app.cpp index b090e6ad6..e67ff9e1c 100644 --- a/test/test_apps/triangle/app.cpp +++ b/test/test_apps/triangle/app.cpp @@ -52,7 +52,7 @@ class App : public gfxrecon::test::TestAppBase VkPipelineLayout pipeline_layout; VkPipeline graphics_pipeline; - VkCommandPool command_pools[MAX_FRAMES_IN_FLIGHT]; + VkCommandPool command_pools[MAX_FRAMES_IN_FLIGHT]; size_t current_frame = 0; @@ -282,9 +282,9 @@ bool App::frame(const int frame_num) init.disp.resetCommandPool(this->command_pools[current_frame], 0); VkCommandBufferAllocateInfo allocate_info = {}; - allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; - allocate_info.commandBufferCount = 1; - allocate_info.commandPool = this->command_pools[current_frame]; + allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO; + allocate_info.commandBufferCount = 1; + allocate_info.commandPool = this->command_pools[current_frame]; VkCommandBuffer command_buffer; result = init.disp.allocateCommandBuffers(&allocate_info, &command_buffer); VERIFY_VK_RESULT("failed to allocate command buffer", result); @@ -292,12 +292,12 @@ bool App::frame(const int frame_num) { VkCommandBufferBeginInfo begin_info = {}; begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO; - result = init.disp.beginCommandBuffer(command_buffer, &begin_info); + result = init.disp.beginCommandBuffer(command_buffer, &begin_info); VERIFY_VK_RESULT("failed to create command buffer", result); { VkImageMemoryBarrier image_barrier = {}; - image_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + image_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; image_barrier.image = init.swapchain_images[image_index]; image_barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED; image_barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; @@ -353,7 +353,7 @@ bool App::frame(const int frame_num) { VkImageMemoryBarrier image_barrier = {}; - image_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; + image_barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER; image_barrier.image = init.swapchain_images[image_index]; image_barrier.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; image_barrier.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; @@ -469,7 +469,8 @@ void App::setup() auto queue_family_index = init.device.get_queue_index(gfxrecon::test::QueueType::graphics); if (!queue_family_index) throw std::runtime_error("could not find graphics queue"); - for (auto& command_pool : command_pools) { + for (auto& command_pool : command_pools) + { command_pool = gfxrecon::test::create_command_pool(init.disp, *queue_family_index); }