From 83ef1035bf6ba8333e5859f304dca6bbc5cd4c58 Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Sun, 24 Sep 2023 18:28:13 -0600 Subject: [PATCH] Add the Instance dispatch table While not designed to be called by the user, it is common for other libraries to need function pointers, including instance level functions. --- gen/CurrentBuildVulkanVersion.cmake | 4 +- script/generate_dispatch.py | 252 +++---- src/VkBootstrap.cpp | 2 + src/VkBootstrap.h | 3 + src/VkBootstrapDispatch.h | 983 ++++++++++++++++++++++++++++ tests/bootstrap_tests.cpp | 7 +- 6 files changed, 1133 insertions(+), 118 deletions(-) diff --git a/gen/CurrentBuildVulkanVersion.cmake b/gen/CurrentBuildVulkanVersion.cmake index c417db2..b3f2a51 100644 --- a/gen/CurrentBuildVulkanVersion.cmake +++ b/gen/CurrentBuildVulkanVersion.cmake @@ -1,2 +1,2 @@ -set(VK_BOOTSTRAP_SOURCE_HEADER_VERSION 1.3.264) -set(VK_BOOTSTRAP_SOURCE_HEADER_VERSION_GIT_TAG v1.3.264) +set(VK_BOOTSTRAP_SOURCE_HEADER_VERSION 1.3.265) +set(VK_BOOTSTRAP_SOURCE_HEADER_VERSION_GIT_TAG v1.3.265) diff --git a/script/generate_dispatch.py b/script/generate_dispatch.py index 0697fca..f9905e5 100644 --- a/script/generate_dispatch.py +++ b/script/generate_dispatch.py @@ -95,9 +95,12 @@ vk_xml_raw = response.read() vk_xml = xmltodict.parse(vk_xml_raw,process_namespaces=True) -command_params = {'return_type': '', 'args': [], 'requirements': [], 'macro_template': Template('')} +command_params = {'return_type': '', 'args': [], 'dispatch_type': '', 'requirements': [], 'macro_template': Template('')} -device_commands = {} +commands = {} + +INSTANCE = 'instance' +DEVICE = 'device' aliased_types = {} types_node = vk_xml['registry']['types']['type'] @@ -123,17 +126,20 @@ for command_node in commands_node: if not '@api' in param or param['@api'] == 'vulkan': new_command_params['args'].append(param) if not command_name in exclusions: + commands[command_name] = new_command_params + commands[command_name]['is_alias'] = False if new_command_params['args'][0]['type'] in ['VkDevice', 'VkCommandBuffer', 'VkQueue']: - device_commands[command_name] = new_command_params - device_commands[command_name]['is_alias'] = False + commands[command_name]['dispatch_type'] = DEVICE + elif new_command_params['args'][0]['type'] in ['VkInstance', 'VkPhysicalDevice']: + commands[command_name]['dispatch_type'] = INSTANCE elif '@alias' in command_node: aliases[command_node['@alias']] = command_node['@name'] # Push the alias name as a device function if the alias exists in device commands for alias_name, alias in aliases.items(): - if alias in device_commands: - device_commands[alias] = copy.deepcopy(device_commands[alias_name]) - device_commands[alias]['is_alias'] = True + if alias in commands: + commands[alias] = copy.deepcopy(commands[alias_name]) + commands[alias]['is_alias'] = True # Add requirements for core PFN's features_node = vk_xml['registry']['feature'] @@ -145,8 +151,8 @@ for feature_node in features_node: if not isinstance(require_node[param_node], list): require_node[param_node] = [require_node[param_node]] for param in require_node[param_node]: - if param['@name'] in device_commands: - device_commands[param['@name']]['requirements'] += [[feature_node['@name']]] + if param['@name'] in commands: + commands[param['@name']]['requirements'] += [[feature_node['@name']]] # Add requirements for extension PFN's @@ -166,25 +172,25 @@ for extension_node in extensions_node: if not isinstance(require_node['command'], list): require_node['command'] = [require_node['command']] for command_node in require_node['command']: - if command_node['@name'] in device_commands: + if command_node['@name'] in commands: if '@author' in extension_node and extension_node['@author'] in excluded_extension_authors: - device_commands.pop(command_node['@name']) + commands.pop(command_node['@name']) else: - device_commands[command_node['@name']]['requirements'] += [requirements] + commands[command_node['@name']]['requirements'] += [requirements] elif require_node == 'command': if not isinstance(require_nodes['command'], list): require_nodes['command'] = [require_nodes['command']] for command_node in require_nodes['command']: - if command_node['@name'] in device_commands: + if command_node['@name'] in commands: if '@author' in extension_node and extension_node['@author'] in excluded_extension_authors: - device_commands.pop(command_node['@name']) + commands.pop(command_node['@name']) else: - device_commands[command_node['@name']]['requirements'] += [requirements] + commands[command_node['@name']]['requirements'] += [requirements] # Generate macro templates -for command_name, command in device_commands.items(): +for command_name, command in commands.items(): macro = '' - requirements_collection = device_commands[command_name]['requirements'] + requirements_collection = commands[command_name]['requirements'] collection_count = len(requirements_collection) if collection_count > 0: macro = '#if ' @@ -205,7 +211,7 @@ for command_name, command in device_commands.items(): macro += '\n$body#endif\n' else: macro = '$body' - device_commands[command_name]['macro_template'] = Template(macro) + commands[command_name]['macro_template'] = Template(macro) # License dispatch_license = '''/* @@ -232,108 +238,126 @@ info = '// This file is a part of VkBootstrap\n' info += '// https://github.com/charles-lunarg/vk-bootstrap\n\n' # # Content -body = '\n#pragma once\n\n#include \n\n' -body += 'namespace vkb {\n\n' -body += 'struct DispatchTable {\n' -body += '\tDispatchTable() = default;\n' -body += '\tDispatchTable(VkDevice device, PFN_vkGetDeviceProcAddr procAddr) : device(device), populated(true) {\n' +head = '\n#pragma once\n\n#include \n\n' +head += 'namespace vkb {\n\n' -proxy_section = '' -fp_decl_section = '' -pfn_load_section = '' - -proxy_template = Template('\t$return_type $proxy_name($args_full) const noexcept {\n\t\t$opt_return$fp_name($args_names);\n\t}\n') -fp_decl_template = Template('\t$pfn_name $fp_name = nullptr;\n') -pfn_load_template = Template('\t\t$fp_name = reinterpret_cast<$pfn_name>(procAddr(device, "$command_name"));\n') - -for command_name, command in device_commands.items(): - params = device_commands[command] - # easy stuff out of the way - return_type = params['return_type'] - if return_type != 'void': - opt_return = 'return ' +def create_dispatch_table(dispatch_type): + out = '' + if dispatch_type == INSTANCE: + out += 'struct InstanceDispatchTable {\n' + out += '\tInstanceDispatchTable() = default;\n' + out += '\tInstanceDispatchTable(VkInstance instance, PFN_vkGetInstanceProcAddr procAddr) : instance(instance), populated(true) {\n' else: - opt_return = '' - proxy_name = command_name[2].lower() + command_name[3:] - fp_name = 'fp_' + command_name - pfn_name = 'PFN_' + command_name + out += 'struct DispatchTable {\n' + out += '\tDispatchTable() = default;\n' + out += '\tDispatchTable(VkDevice device, PFN_vkGetDeviceProcAddr procAddr) : device(device), populated(true) {\n' - # Now for args - arg_template = Template('$front_mods$arg_type$back_mods$arg_name$array') - args_full = '' - args_names = '' - args_count = len(params['args']) - i = args_count - for arg in params['args']: - front_mods = '' - back_mods = ' ' - array = '' - arg_type = arg['type'] - arg_name = arg['name'] - if '#text' in arg: - text = arg['#text'] - text = text.replace(' ', '') - array_index = text.find('[') - if array_index != -1: - array = text[array_index:] - text = text[0:array_index] - if text == '*': - front_mods = '' - back_mods = '* ' - elif text == '**': - front_mods = '' - back_mods = '** ' - elif text == 'struct**': - front_mods = 'struct ' - back_mods = '** ' - elif text == 'const*': - front_mods = 'const ' - back_mods = '* ' - elif text == 'const**': - front_mods = 'const ' - back_mods = '** ' - elif text == 'const*const*': - front_mods = 'const ' - back_mods = '* const* ' - elif text == 'conststruct*': - front_mods = 'const struct ' - back_mods = '* ' - if i == args_count and arg_type == 'VkDevice': - args_names += arg_name - if i > 0: - i -= 1 - if i > 0: - args_names += ', ' + proxy_section = '' + fp_decl_section = '' + pfn_load_section = '' + + proxy_template = Template('\t$return_type $proxy_name($args_full) const noexcept {\n\t\t$opt_return$fp_name($args_names);\n\t}\n') + fp_decl_template = Template('\t$pfn_name $fp_name = nullptr;\n') + if dispatch_type == INSTANCE: + pfn_load_template = Template('\t\t$fp_name = reinterpret_cast<$pfn_name>(procAddr(instance, "$command_name"));\n') + else: + pfn_load_template = Template('\t\t$fp_name = reinterpret_cast<$pfn_name>(procAddr(device, "$command_name"));\n') + + for command_name, command in commands.items(): + if command['dispatch_type'] != dispatch_type: + continue + params = commands[command_name] + # easy stuff out of the way + return_type = params['return_type'] + if return_type != 'void': + opt_return = 'return ' else: - if arg_type in aliased_types and arg_type not in excluded_alias_types: - arg_type = aliased_types[arg_type] - args_full += arg_template.substitute(front_mods = front_mods, arg_type = arg_type, back_mods = back_mods, arg_name = arg_name, array = array) - args_names += arg_name - if i > 0: - i -= 1 + opt_return = '' + proxy_name = command_name[2].lower() + command_name[3:] + fp_name = 'fp_' + command_name + pfn_name = 'PFN_' + command_name + + # Now for args + arg_template = Template('$front_mods$arg_type$back_mods$arg_name$array') + args_full = '' + args_names = '' + args_count = len(params['args']) + i = args_count + for arg in params['args']: + front_mods = '' + back_mods = ' ' + array = '' + arg_type = arg['type'] + arg_name = arg['name'] + if '#text' in arg: + text = arg['#text'] + text = text.replace(' ', '') + array_index = text.find('[') + if array_index != -1: + array = text[array_index:] + text = text[0:array_index] + if text == '*': + front_mods = '' + back_mods = '* ' + elif text == '**': + front_mods = '' + back_mods = '** ' + elif text == 'struct**': + front_mods = 'struct ' + back_mods = '** ' + elif text == 'const*': + front_mods = 'const ' + back_mods = '* ' + elif text == 'const**': + front_mods = 'const ' + back_mods = '** ' + elif text == 'const*const*': + front_mods = 'const ' + back_mods = '* const* ' + elif text == 'conststruct*': + front_mods = 'const struct ' + back_mods = '* ' + if i == args_count and (dispatch_type == INSTANCE and arg_type == 'VkInstance') or (dispatch_type == DEVICE and arg_type == 'VkDevice'): + args_names += arg_name if i > 0: - args_full += ', ' - args_names += ', ' + i -= 1 + if i > 0: + args_names += ', ' + else: + if arg_type in aliased_types and arg_type not in excluded_alias_types: + arg_type = aliased_types[arg_type] + args_full += arg_template.substitute(front_mods = front_mods, arg_type = arg_type, back_mods = back_mods, arg_name = arg_name, array = array) + args_names += arg_name + if i > 0: + i -= 1 + if i > 0: + args_full += ', ' + args_names += ', ' - proxy_body = proxy_template.substitute(return_type = return_type, proxy_name = proxy_name, args_full = args_full, opt_return = opt_return, fp_name = fp_name, args_names = args_names) - fp_decl_body = fp_decl_template.substitute(pfn_name = pfn_name, fp_name = fp_name) - pfn_load_body = pfn_load_template.substitute(fp_name = fp_name, pfn_name = pfn_name, command_name = command) + proxy_body = proxy_template.substitute(return_type = return_type, proxy_name = proxy_name, args_full = args_full, opt_return = opt_return, fp_name = fp_name, args_names = args_names) + fp_decl_body = fp_decl_template.substitute(pfn_name = pfn_name, fp_name = fp_name) + pfn_load_body = pfn_load_template.substitute(fp_name = fp_name, pfn_name = pfn_name, command_name = command_name) - macro_template = params['macro_template'] - proxy_section += macro_template.substitute(body=proxy_body) - fp_decl_section += macro_template.substitute(body=fp_decl_body) - pfn_load_section +=macro_template.substitute(body=pfn_load_body) + macro_template = params['macro_template'] + proxy_section += macro_template.substitute(body=proxy_body) + fp_decl_section += macro_template.substitute(body=fp_decl_body) + pfn_load_section += macro_template.substitute(body=pfn_load_body) -body += pfn_load_section -body += '\t}\n' -body += proxy_section -body += fp_decl_section -body += '\tbool is_populated() const { return populated; }\n' -body += '\tVkDevice device = VK_NULL_HANDLE;\n' -body += 'private:\n' -body += '\t bool populated = false;\n' -body += '};\n\n' -body += '} // namespace vkb' + out += pfn_load_section + out += '\t}\n' + out += proxy_section + out += fp_decl_section + out += '\tbool is_populated() const { return populated; }\n' + if dispatch_type == INSTANCE: + out += '\tVkInstance instance = VK_NULL_HANDLE;\n' + else: + out += '\tVkDevice device = VK_NULL_HANDLE;\n' + out += 'private:\n' + out += '\t bool populated = false;\n' + out += '};\n\n' + return out + +tail = '} // namespace vkb' # find the version used to generate the code for type_node in types_node: @@ -346,8 +370,6 @@ version_fields = find_number_fields.findall(complete_header_version) header_version_field = find_number_fields.findall(vk_header_version)[0] version_tag = f'{version_fields[1]}.{version_fields[2]}.{header_version_field}' -header = dispatch_license + info + body - path_to_src = os.path.join('src') if not os.path.exists(path_to_src): path_to_src = os.path.join('..', 'src') @@ -356,7 +378,7 @@ if not os.path.exists(path_to_src): sys.exit() header_file = codecs.open(os.path.join(path_to_src,'VkBootstrapDispatch.h'), 'w', 'utf-8') -header_file.write(header) +header_file.write(dispatch_license + info + head + create_dispatch_table('instance') + create_dispatch_table('device') + tail) header_file.close() path_to_gen = os.path.join('gen') diff --git a/src/VkBootstrap.cpp b/src/VkBootstrap.cpp index d78d686..5e91852 100644 --- a/src/VkBootstrap.cpp +++ b/src/VkBootstrap.cpp @@ -529,6 +529,8 @@ void destroy_instance(Instance instance) { Instance::operator VkInstance() const { return this->instance; } +InstanceDispatchTable Instance::make_table() const { return { instance, fp_vkGetInstanceProcAddr }; } + InstanceBuilder::InstanceBuilder(PFN_vkGetInstanceProcAddr fp_vkGetInstanceProcAddr) { info.fp_vkGetInstanceProcAddr = fp_vkGetInstanceProcAddr; } diff --git a/src/VkBootstrap.h b/src/VkBootstrap.h index fa7355d..e0de398 100644 --- a/src/VkBootstrap.h +++ b/src/VkBootstrap.h @@ -286,6 +286,9 @@ struct Instance { // in places where VkInstance would have been used. operator VkInstance() const; + // Return a loaded instance dispatch table + InstanceDispatchTable make_table() const; + private: bool headless = false; bool properties2_ext_enabled = false; diff --git a/src/VkBootstrapDispatch.h b/src/VkBootstrapDispatch.h index 2c39879..0beed9d 100644 --- a/src/VkBootstrapDispatch.h +++ b/src/VkBootstrapDispatch.h @@ -25,6 +25,989 @@ namespace vkb { +struct InstanceDispatchTable { + InstanceDispatchTable() = default; + 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")); +#if (defined(VK_KHR_android_surface)) + fp_vkCreateAndroidSurfaceKHR = reinterpret_cast(procAddr(instance, "vkCreateAndroidSurfaceKHR")); +#endif +#if (defined(VK_KHR_display)) + fp_vkGetPhysicalDeviceDisplayPropertiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceDisplayPropertiesKHR")); +#endif +#if (defined(VK_KHR_display)) + fp_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR")); +#endif +#if (defined(VK_KHR_display)) + fp_vkGetDisplayPlaneSupportedDisplaysKHR = reinterpret_cast(procAddr(instance, "vkGetDisplayPlaneSupportedDisplaysKHR")); +#endif +#if (defined(VK_KHR_display)) + fp_vkGetDisplayModePropertiesKHR = reinterpret_cast(procAddr(instance, "vkGetDisplayModePropertiesKHR")); +#endif +#if (defined(VK_KHR_display)) + fp_vkCreateDisplayModeKHR = reinterpret_cast(procAddr(instance, "vkCreateDisplayModeKHR")); +#endif +#if (defined(VK_KHR_display)) + fp_vkGetDisplayPlaneCapabilitiesKHR = reinterpret_cast(procAddr(instance, "vkGetDisplayPlaneCapabilitiesKHR")); +#endif +#if (defined(VK_KHR_display)) + 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")); +#endif +#if (defined(VK_KHR_surface)) + fp_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilitiesKHR")); +#endif +#if (defined(VK_KHR_surface)) + fp_vkGetPhysicalDeviceSurfaceFormatsKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSurfaceFormatsKHR")); +#endif +#if (defined(VK_KHR_surface)) + 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")); +#endif +#if (defined(VK_KHR_wayland_surface)) + fp_vkGetPhysicalDeviceWaylandPresentationSupportKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceWaylandPresentationSupportKHR")); +#endif +#if (defined(VK_KHR_win32_surface)) + fp_vkCreateWin32SurfaceKHR = reinterpret_cast(procAddr(instance, "vkCreateWin32SurfaceKHR")); +#endif +#if (defined(VK_KHR_win32_surface)) + fp_vkGetPhysicalDeviceWin32PresentationSupportKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceWin32PresentationSupportKHR")); +#endif +#if (defined(VK_KHR_xlib_surface)) + fp_vkCreateXlibSurfaceKHR = reinterpret_cast(procAddr(instance, "vkCreateXlibSurfaceKHR")); +#endif +#if (defined(VK_KHR_xlib_surface)) + fp_vkGetPhysicalDeviceXlibPresentationSupportKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR")); +#endif +#if (defined(VK_KHR_xcb_surface)) + fp_vkCreateXcbSurfaceKHR = reinterpret_cast(procAddr(instance, "vkCreateXcbSurfaceKHR")); +#endif +#if (defined(VK_KHR_xcb_surface)) + fp_vkGetPhysicalDeviceXcbPresentationSupportKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR")); +#endif +#if (defined(VK_EXT_directfb_surface)) + fp_vkCreateDirectFBSurfaceEXT = reinterpret_cast(procAddr(instance, "vkCreateDirectFBSurfaceEXT")); +#endif +#if (defined(VK_EXT_directfb_surface)) + fp_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceDirectFBPresentationSupportEXT")); +#endif +#if (defined(VK_FUCHSIA_imagepipe_surface)) + fp_vkCreateImagePipeSurfaceFUCHSIA = reinterpret_cast(procAddr(instance, "vkCreateImagePipeSurfaceFUCHSIA")); +#endif +#if (defined(VK_GGP_stream_descriptor_surface)) + fp_vkCreateStreamDescriptorSurfaceGGP = reinterpret_cast(procAddr(instance, "vkCreateStreamDescriptorSurfaceGGP")); +#endif +#if (defined(VK_QNX_screen_surface)) + fp_vkCreateScreenSurfaceQNX = reinterpret_cast(procAddr(instance, "vkCreateScreenSurfaceQNX")); +#endif +#if (defined(VK_QNX_screen_surface)) + fp_vkGetPhysicalDeviceScreenPresentationSupportQNX = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceScreenPresentationSupportQNX")); +#endif +#if (defined(VK_EXT_debug_report)) + fp_vkCreateDebugReportCallbackEXT = reinterpret_cast(procAddr(instance, "vkCreateDebugReportCallbackEXT")); +#endif +#if (defined(VK_EXT_debug_report)) + fp_vkDestroyDebugReportCallbackEXT = reinterpret_cast(procAddr(instance, "vkDestroyDebugReportCallbackEXT")); +#endif +#if (defined(VK_EXT_debug_report)) + fp_vkDebugReportMessageEXT = reinterpret_cast(procAddr(instance, "vkDebugReportMessageEXT")); +#endif +#if (defined(VK_NV_external_memory_capabilities)) + fp_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceExternalImageFormatPropertiesNV")); +#endif +#if (defined(VK_VERSION_1_1)) + fp_vkGetPhysicalDeviceFeatures2 = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceFeatures2")); +#endif +#if (defined(VK_VERSION_1_1)) + fp_vkGetPhysicalDeviceProperties2 = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceProperties2")); +#endif +#if (defined(VK_VERSION_1_1)) + fp_vkGetPhysicalDeviceFormatProperties2 = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceFormatProperties2")); +#endif +#if (defined(VK_VERSION_1_1)) + fp_vkGetPhysicalDeviceImageFormatProperties2 = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceImageFormatProperties2")); +#endif +#if (defined(VK_VERSION_1_1)) + fp_vkGetPhysicalDeviceQueueFamilyProperties2 = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceQueueFamilyProperties2")); +#endif +#if (defined(VK_VERSION_1_1)) + fp_vkGetPhysicalDeviceMemoryProperties2 = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceMemoryProperties2")); +#endif +#if (defined(VK_VERSION_1_1)) + fp_vkGetPhysicalDeviceSparseImageFormatProperties2 = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSparseImageFormatProperties2")); +#endif +#if (defined(VK_VERSION_1_1)) + fp_vkGetPhysicalDeviceExternalBufferProperties = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceExternalBufferProperties")); +#endif +#if (defined(VK_NV_external_memory_sci_buf)) + fp_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV")); +#endif +#if (defined(VK_NV_external_memory_sci_buf)) + fp_vkGetPhysicalDeviceSciBufAttributesNV = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSciBufAttributesNV")); +#endif +#if (defined(VK_VERSION_1_1)) + fp_vkGetPhysicalDeviceExternalSemaphoreProperties = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceExternalSemaphoreProperties")); +#endif +#if (defined(VK_VERSION_1_1)) + 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")); +#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")); +#endif +#if (defined(VK_EXT_acquire_xlib_display)) + fp_vkGetRandROutputDisplayEXT = reinterpret_cast(procAddr(instance, "vkGetRandROutputDisplayEXT")); +#endif +#if (defined(VK_NV_acquire_winrt_display)) + 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")); +#endif +#if (defined(VK_VERSION_1_1)) + 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")); +#endif +#if (defined(VK_MVK_ios_surface)) + fp_vkCreateIOSSurfaceMVK = reinterpret_cast(procAddr(instance, "vkCreateIOSSurfaceMVK")); +#endif +#if (defined(VK_MVK_macos_surface)) + fp_vkCreateMacOSSurfaceMVK = reinterpret_cast(procAddr(instance, "vkCreateMacOSSurfaceMVK")); +#endif +#if (defined(VK_EXT_metal_surface)) + fp_vkCreateMetalSurfaceEXT = reinterpret_cast(procAddr(instance, "vkCreateMetalSurfaceEXT")); +#endif +#if (defined(VK_EXT_sample_locations)) + fp_vkGetPhysicalDeviceMultisamplePropertiesEXT = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceMultisamplePropertiesEXT")); +#endif +#if (defined(VK_KHR_get_surface_capabilities2)) + fp_vkGetPhysicalDeviceSurfaceCapabilities2KHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSurfaceCapabilities2KHR")); +#endif +#if (defined(VK_KHR_get_surface_capabilities2)) + fp_vkGetPhysicalDeviceSurfaceFormats2KHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSurfaceFormats2KHR")); +#endif +#if (defined(VK_KHR_get_display_properties2)) + fp_vkGetPhysicalDeviceDisplayProperties2KHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceDisplayProperties2KHR")); +#endif +#if (defined(VK_KHR_get_display_properties2)) + fp_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceDisplayPlaneProperties2KHR")); +#endif +#if (defined(VK_KHR_get_display_properties2)) + fp_vkGetDisplayModeProperties2KHR = reinterpret_cast(procAddr(instance, "vkGetDisplayModeProperties2KHR")); +#endif +#if (defined(VK_KHR_get_display_properties2)) + fp_vkGetDisplayPlaneCapabilities2KHR = reinterpret_cast(procAddr(instance, "vkGetDisplayPlaneCapabilities2KHR")); +#endif +#if (defined(VK_EXT_calibrated_timestamps)) + fp_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceCalibrateableTimeDomainsEXT")); +#endif +#if (defined(VK_EXT_debug_utils)) + fp_vkCreateDebugUtilsMessengerEXT = reinterpret_cast(procAddr(instance, "vkCreateDebugUtilsMessengerEXT")); +#endif +#if (defined(VK_EXT_debug_utils)) + fp_vkDestroyDebugUtilsMessengerEXT = reinterpret_cast(procAddr(instance, "vkDestroyDebugUtilsMessengerEXT")); +#endif +#if (defined(VK_EXT_debug_utils)) + fp_vkSubmitDebugUtilsMessageEXT = reinterpret_cast(procAddr(instance, "vkSubmitDebugUtilsMessageEXT")); +#endif +#if (defined(VK_NV_cooperative_matrix)) + fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesNV")); +#endif +#if (defined(VK_EXT_full_screen_exclusive)) + fp_vkGetPhysicalDeviceSurfacePresentModes2EXT = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSurfacePresentModes2EXT")); +#endif +#if (defined(VK_KHR_performance_query)) + fp_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = reinterpret_cast(procAddr(instance, "vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR")); +#endif +#if (defined(VK_KHR_performance_query)) + fp_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR")); +#endif +#if (defined(VK_EXT_headless_surface)) + fp_vkCreateHeadlessSurfaceEXT = reinterpret_cast(procAddr(instance, "vkCreateHeadlessSurfaceEXT")); +#endif +#if (defined(VK_NV_coverage_reduction_mode)) + fp_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV")); +#endif +#if (defined(VK_VERSION_1_3)) + fp_vkGetPhysicalDeviceToolProperties = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceToolProperties")); +#endif +#if (defined(VK_KHR_object_refresh)) + fp_vkGetPhysicalDeviceRefreshableObjectTypesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceRefreshableObjectTypesKHR")); +#endif +#if (defined(VK_KHR_fragment_shading_rate)) + fp_vkGetPhysicalDeviceFragmentShadingRatesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceFragmentShadingRatesKHR")); +#endif +#if (defined(VK_KHR_video_queue)) + fp_vkGetPhysicalDeviceVideoCapabilitiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceVideoCapabilitiesKHR")); +#endif +#if (defined(VK_KHR_video_queue)) + fp_vkGetPhysicalDeviceVideoFormatPropertiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceVideoFormatPropertiesKHR")); +#endif +#if (defined(VK_KHR_video_encode_queue)) + fp_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR")); +#endif +#if (defined(VK_EXT_acquire_drm_display)) + 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")); +#endif +#if (defined(VK_KHR_cooperative_matrix)) + fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = reinterpret_cast(procAddr(instance, "vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR")); +#endif + } + void destroyInstance(const VkAllocationCallbacks* pAllocator) const noexcept { + fp_vkDestroyInstance(instance, pAllocator); + } + VkResult enumeratePhysicalDevices(uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) const noexcept { + return fp_vkEnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); + } + PFN_vkVoidFunction getInstanceProcAddr(const char* pName) const noexcept { + return fp_vkGetInstanceProcAddr(instance, pName); + } + void getPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) const noexcept { + fp_vkGetPhysicalDeviceProperties(physicalDevice, pProperties); + } + void getPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) const noexcept { + fp_vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); + } + void getPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) const noexcept { + fp_vkGetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); + } + void getPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) const noexcept { + fp_vkGetPhysicalDeviceFeatures(physicalDevice, pFeatures); + } + 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 { + return fp_vkEnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties); + } + 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); + } +#if (defined(VK_KHR_android_surface)) + 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 { + return fp_vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, pPropertyCount, pProperties); + } +#endif +#if (defined(VK_KHR_display)) + 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 { + 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 { + 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 { + 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 { + 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 { + return fp_vkCreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); + } +#endif +#if (defined(VK_KHR_surface)) + 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 { + return fp_vkGetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); + } +#endif +#if (defined(VK_KHR_surface)) + 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 { + 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 { + 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 { + 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 { + return fp_vkCreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); + } +#endif +#if (defined(VK_KHR_wayland_surface)) + VkBool32 getPhysicalDeviceWaylandPresentationSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, 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 { + return fp_vkCreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); + } +#endif +#if (defined(VK_KHR_win32_surface)) + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + 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 { + return fp_vkCreateScreenSurfaceQNX(instance, pCreateInfo, pAllocator, pSurface); + } +#endif +#if (defined(VK_QNX_screen_surface)) + VkBool32 getPhysicalDeviceScreenPresentationSupportQNX(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, _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 { + return fp_vkCreateDebugReportCallbackEXT(instance, pCreateInfo, pAllocator, pCallback); + } +#endif +#if (defined(VK_EXT_debug_report)) + 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 { + 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); + } +#endif +#if (defined(VK_VERSION_1_1)) + 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 { + fp_vkGetPhysicalDeviceProperties2(physicalDevice, pProperties); + } +#endif +#if (defined(VK_VERSION_1_1)) + 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 { + return fp_vkGetPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties); + } +#endif +#if (defined(VK_VERSION_1_1)) + 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 { + 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 { + fp_vkGetPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties); + } +#endif +#if (defined(VK_VERSION_1_1)) + 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); + } +#endif +#if (defined(VK_NV_external_memory_sci_buf)) + 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); + } +#endif +#if (defined(VK_VERSION_1_1)) + 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 { + return fp_vkGetPhysicalDeviceSciSyncAttributesNV(physicalDevice, pSciSyncAttributesInfo, pAttributes); + } +#endif +#if (defined(VK_EXT_direct_mode_display)) + 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 { + 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 { + return fp_vkGetRandROutputDisplayEXT(physicalDevice, dpy, rrOutput, pDisplay); + } +#endif +#if (defined(VK_NV_acquire_winrt_display)) + 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 { + return fp_vkGetWinrtDisplayNV(physicalDevice, deviceRelativeId, pDisplay); + } +#endif +#if (defined(VK_EXT_display_surface_counter)) + 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 { + 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 { + 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 { + 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 { + 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 { + return fp_vkCreateMetalSurfaceEXT(instance, pCreateInfo, pAllocator, pSurface); + } +#endif +#if (defined(VK_EXT_sample_locations)) + 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 { + 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); + } +#endif +#if (defined(VK_KHR_get_display_properties2)) + 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 { + 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 { + 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 { + return fp_vkGetDisplayPlaneCapabilities2KHR(physicalDevice, pDisplayPlaneInfo, pCapabilities); + } +#endif +#if (defined(VK_EXT_calibrated_timestamps)) + VkResult getPhysicalDeviceCalibrateableTimeDomainsEXT(VkPhysicalDevice physicalDevice, uint32_t* pTimeDomainCount, VkTimeDomainEXT* pTimeDomains) const noexcept { + return fp_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT(physicalDevice, pTimeDomainCount, pTimeDomains); + } +#endif +#if (defined(VK_EXT_debug_utils)) + 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 { + fp_vkDestroyDebugUtilsMessengerEXT(instance, messenger, pAllocator); + } +#endif +#if (defined(VK_EXT_debug_utils)) + 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 { + 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); + } +#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); + } +#endif +#if (defined(VK_KHR_performance_query)) + 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 { + 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); + } +#endif +#if (defined(VK_VERSION_1_3)) + 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); + } +#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); + } +#endif +#if (defined(VK_KHR_video_queue)) + 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); + } +#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); + } +#endif +#if (defined(VK_EXT_acquire_drm_display)) + 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 { + 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); + } +#endif +#if (defined(VK_KHR_cooperative_matrix)) + VkResult getPhysicalDeviceCooperativeMatrixPropertiesKHR(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkCooperativeMatrixPropertiesKHR* pProperties) const noexcept { + return fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR(physicalDevice, pPropertyCount, pProperties); + } +#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_vkGetPhysicalDeviceSparseImageFormatProperties fp_vkGetPhysicalDeviceSparseImageFormatProperties = nullptr; +#if (defined(VK_KHR_android_surface)) + PFN_vkCreateAndroidSurfaceKHR fp_vkCreateAndroidSurfaceKHR = nullptr; +#endif +#if (defined(VK_KHR_display)) + PFN_vkGetPhysicalDeviceDisplayPropertiesKHR fp_vkGetPhysicalDeviceDisplayPropertiesKHR = nullptr; +#endif +#if (defined(VK_KHR_display)) + PFN_vkGetPhysicalDeviceDisplayPlanePropertiesKHR fp_vkGetPhysicalDeviceDisplayPlanePropertiesKHR = nullptr; +#endif +#if (defined(VK_KHR_display)) + PFN_vkGetDisplayPlaneSupportedDisplaysKHR fp_vkGetDisplayPlaneSupportedDisplaysKHR = nullptr; +#endif +#if (defined(VK_KHR_display)) + PFN_vkGetDisplayModePropertiesKHR fp_vkGetDisplayModePropertiesKHR = nullptr; +#endif +#if (defined(VK_KHR_display)) + PFN_vkCreateDisplayModeKHR fp_vkCreateDisplayModeKHR = nullptr; +#endif +#if (defined(VK_KHR_display)) + PFN_vkGetDisplayPlaneCapabilitiesKHR fp_vkGetDisplayPlaneCapabilitiesKHR = nullptr; +#endif +#if (defined(VK_KHR_display)) + PFN_vkCreateDisplayPlaneSurfaceKHR fp_vkCreateDisplayPlaneSurfaceKHR = nullptr; +#endif +#if (defined(VK_KHR_surface)) + PFN_vkDestroySurfaceKHR fp_vkDestroySurfaceKHR = nullptr; +#endif +#if (defined(VK_KHR_surface)) + PFN_vkGetPhysicalDeviceSurfaceSupportKHR fp_vkGetPhysicalDeviceSurfaceSupportKHR = nullptr; +#endif +#if (defined(VK_KHR_surface)) + PFN_vkGetPhysicalDeviceSurfaceCapabilitiesKHR fp_vkGetPhysicalDeviceSurfaceCapabilitiesKHR = nullptr; +#endif +#if (defined(VK_KHR_surface)) + PFN_vkGetPhysicalDeviceSurfaceFormatsKHR fp_vkGetPhysicalDeviceSurfaceFormatsKHR = nullptr; +#endif +#if (defined(VK_KHR_surface)) + PFN_vkGetPhysicalDeviceSurfacePresentModesKHR fp_vkGetPhysicalDeviceSurfacePresentModesKHR = nullptr; +#endif +#if (defined(VK_NN_vi_surface)) + PFN_vkCreateViSurfaceNN fp_vkCreateViSurfaceNN = nullptr; +#endif +#if (defined(VK_KHR_wayland_surface)) + PFN_vkCreateWaylandSurfaceKHR fp_vkCreateWaylandSurfaceKHR = nullptr; +#endif +#if (defined(VK_KHR_wayland_surface)) + PFN_vkGetPhysicalDeviceWaylandPresentationSupportKHR fp_vkGetPhysicalDeviceWaylandPresentationSupportKHR = nullptr; +#endif +#if (defined(VK_KHR_win32_surface)) + PFN_vkCreateWin32SurfaceKHR fp_vkCreateWin32SurfaceKHR = nullptr; +#endif +#if (defined(VK_KHR_win32_surface)) + PFN_vkGetPhysicalDeviceWin32PresentationSupportKHR fp_vkGetPhysicalDeviceWin32PresentationSupportKHR = nullptr; +#endif +#if (defined(VK_KHR_xlib_surface)) + PFN_vkCreateXlibSurfaceKHR fp_vkCreateXlibSurfaceKHR = nullptr; +#endif +#if (defined(VK_KHR_xlib_surface)) + PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR fp_vkGetPhysicalDeviceXlibPresentationSupportKHR = nullptr; +#endif +#if (defined(VK_KHR_xcb_surface)) + PFN_vkCreateXcbSurfaceKHR fp_vkCreateXcbSurfaceKHR = nullptr; +#endif +#if (defined(VK_KHR_xcb_surface)) + PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR fp_vkGetPhysicalDeviceXcbPresentationSupportKHR = nullptr; +#endif +#if (defined(VK_EXT_directfb_surface)) + PFN_vkCreateDirectFBSurfaceEXT fp_vkCreateDirectFBSurfaceEXT = nullptr; +#endif +#if (defined(VK_EXT_directfb_surface)) + PFN_vkGetPhysicalDeviceDirectFBPresentationSupportEXT fp_vkGetPhysicalDeviceDirectFBPresentationSupportEXT = nullptr; +#endif +#if (defined(VK_FUCHSIA_imagepipe_surface)) + PFN_vkCreateImagePipeSurfaceFUCHSIA fp_vkCreateImagePipeSurfaceFUCHSIA = nullptr; +#endif +#if (defined(VK_GGP_stream_descriptor_surface)) + PFN_vkCreateStreamDescriptorSurfaceGGP fp_vkCreateStreamDescriptorSurfaceGGP = nullptr; +#endif +#if (defined(VK_QNX_screen_surface)) + PFN_vkCreateScreenSurfaceQNX fp_vkCreateScreenSurfaceQNX = nullptr; +#endif +#if (defined(VK_QNX_screen_surface)) + PFN_vkGetPhysicalDeviceScreenPresentationSupportQNX fp_vkGetPhysicalDeviceScreenPresentationSupportQNX = nullptr; +#endif +#if (defined(VK_EXT_debug_report)) + PFN_vkCreateDebugReportCallbackEXT fp_vkCreateDebugReportCallbackEXT = nullptr; +#endif +#if (defined(VK_EXT_debug_report)) + PFN_vkDestroyDebugReportCallbackEXT fp_vkDestroyDebugReportCallbackEXT = nullptr; +#endif +#if (defined(VK_EXT_debug_report)) + PFN_vkDebugReportMessageEXT fp_vkDebugReportMessageEXT = nullptr; +#endif +#if (defined(VK_NV_external_memory_capabilities)) + PFN_vkGetPhysicalDeviceExternalImageFormatPropertiesNV fp_vkGetPhysicalDeviceExternalImageFormatPropertiesNV = nullptr; +#endif +#if (defined(VK_VERSION_1_1)) + PFN_vkGetPhysicalDeviceFeatures2 fp_vkGetPhysicalDeviceFeatures2 = nullptr; +#endif +#if (defined(VK_VERSION_1_1)) + PFN_vkGetPhysicalDeviceProperties2 fp_vkGetPhysicalDeviceProperties2 = nullptr; +#endif +#if (defined(VK_VERSION_1_1)) + PFN_vkGetPhysicalDeviceFormatProperties2 fp_vkGetPhysicalDeviceFormatProperties2 = nullptr; +#endif +#if (defined(VK_VERSION_1_1)) + PFN_vkGetPhysicalDeviceImageFormatProperties2 fp_vkGetPhysicalDeviceImageFormatProperties2 = nullptr; +#endif +#if (defined(VK_VERSION_1_1)) + PFN_vkGetPhysicalDeviceQueueFamilyProperties2 fp_vkGetPhysicalDeviceQueueFamilyProperties2 = nullptr; +#endif +#if (defined(VK_VERSION_1_1)) + PFN_vkGetPhysicalDeviceMemoryProperties2 fp_vkGetPhysicalDeviceMemoryProperties2 = nullptr; +#endif +#if (defined(VK_VERSION_1_1)) + PFN_vkGetPhysicalDeviceSparseImageFormatProperties2 fp_vkGetPhysicalDeviceSparseImageFormatProperties2 = nullptr; +#endif +#if (defined(VK_VERSION_1_1)) + PFN_vkGetPhysicalDeviceExternalBufferProperties fp_vkGetPhysicalDeviceExternalBufferProperties = nullptr; +#endif +#if (defined(VK_NV_external_memory_sci_buf)) + PFN_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV fp_vkGetPhysicalDeviceExternalMemorySciBufPropertiesNV = nullptr; +#endif +#if (defined(VK_NV_external_memory_sci_buf)) + PFN_vkGetPhysicalDeviceSciBufAttributesNV fp_vkGetPhysicalDeviceSciBufAttributesNV = nullptr; +#endif +#if (defined(VK_VERSION_1_1)) + PFN_vkGetPhysicalDeviceExternalSemaphoreProperties fp_vkGetPhysicalDeviceExternalSemaphoreProperties = nullptr; +#endif +#if (defined(VK_VERSION_1_1)) + PFN_vkGetPhysicalDeviceExternalFenceProperties fp_vkGetPhysicalDeviceExternalFenceProperties = nullptr; +#endif +#if (defined(VK_NV_external_sci_sync)) || (defined(VK_NV_external_sci_sync2)) + PFN_vkGetPhysicalDeviceSciSyncAttributesNV fp_vkGetPhysicalDeviceSciSyncAttributesNV = nullptr; +#endif +#if (defined(VK_EXT_direct_mode_display)) + PFN_vkReleaseDisplayEXT fp_vkReleaseDisplayEXT = nullptr; +#endif +#if (defined(VK_EXT_acquire_xlib_display)) + PFN_vkAcquireXlibDisplayEXT fp_vkAcquireXlibDisplayEXT = nullptr; +#endif +#if (defined(VK_EXT_acquire_xlib_display)) + PFN_vkGetRandROutputDisplayEXT fp_vkGetRandROutputDisplayEXT = nullptr; +#endif +#if (defined(VK_NV_acquire_winrt_display)) + PFN_vkAcquireWinrtDisplayNV fp_vkAcquireWinrtDisplayNV = nullptr; +#endif +#if (defined(VK_NV_acquire_winrt_display)) + PFN_vkGetWinrtDisplayNV fp_vkGetWinrtDisplayNV = nullptr; +#endif +#if (defined(VK_EXT_display_surface_counter)) + PFN_vkGetPhysicalDeviceSurfaceCapabilities2EXT fp_vkGetPhysicalDeviceSurfaceCapabilities2EXT = nullptr; +#endif +#if (defined(VK_VERSION_1_1)) + PFN_vkEnumeratePhysicalDeviceGroups fp_vkEnumeratePhysicalDeviceGroups = nullptr; +#endif +#if (defined(VK_KHR_swapchain)) || (defined(VK_KHR_device_group)) + PFN_vkGetPhysicalDevicePresentRectanglesKHR fp_vkGetPhysicalDevicePresentRectanglesKHR = nullptr; +#endif +#if (defined(VK_MVK_ios_surface)) + PFN_vkCreateIOSSurfaceMVK fp_vkCreateIOSSurfaceMVK = nullptr; +#endif +#if (defined(VK_MVK_macos_surface)) + PFN_vkCreateMacOSSurfaceMVK fp_vkCreateMacOSSurfaceMVK = nullptr; +#endif +#if (defined(VK_EXT_metal_surface)) + PFN_vkCreateMetalSurfaceEXT fp_vkCreateMetalSurfaceEXT = nullptr; +#endif +#if (defined(VK_EXT_sample_locations)) + PFN_vkGetPhysicalDeviceMultisamplePropertiesEXT fp_vkGetPhysicalDeviceMultisamplePropertiesEXT = nullptr; +#endif +#if (defined(VK_KHR_get_surface_capabilities2)) + PFN_vkGetPhysicalDeviceSurfaceCapabilities2KHR fp_vkGetPhysicalDeviceSurfaceCapabilities2KHR = nullptr; +#endif +#if (defined(VK_KHR_get_surface_capabilities2)) + PFN_vkGetPhysicalDeviceSurfaceFormats2KHR fp_vkGetPhysicalDeviceSurfaceFormats2KHR = nullptr; +#endif +#if (defined(VK_KHR_get_display_properties2)) + PFN_vkGetPhysicalDeviceDisplayProperties2KHR fp_vkGetPhysicalDeviceDisplayProperties2KHR = nullptr; +#endif +#if (defined(VK_KHR_get_display_properties2)) + PFN_vkGetPhysicalDeviceDisplayPlaneProperties2KHR fp_vkGetPhysicalDeviceDisplayPlaneProperties2KHR = nullptr; +#endif +#if (defined(VK_KHR_get_display_properties2)) + PFN_vkGetDisplayModeProperties2KHR fp_vkGetDisplayModeProperties2KHR = nullptr; +#endif +#if (defined(VK_KHR_get_display_properties2)) + PFN_vkGetDisplayPlaneCapabilities2KHR fp_vkGetDisplayPlaneCapabilities2KHR = nullptr; +#endif +#if (defined(VK_EXT_calibrated_timestamps)) + PFN_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT fp_vkGetPhysicalDeviceCalibrateableTimeDomainsEXT = nullptr; +#endif +#if (defined(VK_EXT_debug_utils)) + PFN_vkCreateDebugUtilsMessengerEXT fp_vkCreateDebugUtilsMessengerEXT = nullptr; +#endif +#if (defined(VK_EXT_debug_utils)) + PFN_vkDestroyDebugUtilsMessengerEXT fp_vkDestroyDebugUtilsMessengerEXT = nullptr; +#endif +#if (defined(VK_EXT_debug_utils)) + PFN_vkSubmitDebugUtilsMessageEXT fp_vkSubmitDebugUtilsMessageEXT = nullptr; +#endif +#if (defined(VK_NV_cooperative_matrix)) + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesNV = nullptr; +#endif +#if (defined(VK_EXT_full_screen_exclusive)) + PFN_vkGetPhysicalDeviceSurfacePresentModes2EXT fp_vkGetPhysicalDeviceSurfacePresentModes2EXT = nullptr; +#endif +#if (defined(VK_KHR_performance_query)) + PFN_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR fp_vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR = nullptr; +#endif +#if (defined(VK_KHR_performance_query)) + PFN_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR fp_vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR = nullptr; +#endif +#if (defined(VK_EXT_headless_surface)) + PFN_vkCreateHeadlessSurfaceEXT fp_vkCreateHeadlessSurfaceEXT = nullptr; +#endif +#if (defined(VK_NV_coverage_reduction_mode)) + PFN_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV fp_vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV = nullptr; +#endif +#if (defined(VK_VERSION_1_3)) + PFN_vkGetPhysicalDeviceToolProperties fp_vkGetPhysicalDeviceToolProperties = nullptr; +#endif +#if (defined(VK_KHR_object_refresh)) + PFN_vkGetPhysicalDeviceRefreshableObjectTypesKHR fp_vkGetPhysicalDeviceRefreshableObjectTypesKHR = nullptr; +#endif +#if (defined(VK_KHR_fragment_shading_rate)) + PFN_vkGetPhysicalDeviceFragmentShadingRatesKHR fp_vkGetPhysicalDeviceFragmentShadingRatesKHR = nullptr; +#endif +#if (defined(VK_KHR_video_queue)) + PFN_vkGetPhysicalDeviceVideoCapabilitiesKHR fp_vkGetPhysicalDeviceVideoCapabilitiesKHR = nullptr; +#endif +#if (defined(VK_KHR_video_queue)) + PFN_vkGetPhysicalDeviceVideoFormatPropertiesKHR fp_vkGetPhysicalDeviceVideoFormatPropertiesKHR = nullptr; +#endif +#if (defined(VK_KHR_video_encode_queue)) + PFN_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR fp_vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR = nullptr; +#endif +#if (defined(VK_EXT_acquire_drm_display)) + PFN_vkAcquireDrmDisplayEXT fp_vkAcquireDrmDisplayEXT = nullptr; +#endif +#if (defined(VK_EXT_acquire_drm_display)) + PFN_vkGetDrmDisplayEXT fp_vkGetDrmDisplayEXT = nullptr; +#endif +#if (defined(VK_NV_optical_flow)) + PFN_vkGetPhysicalDeviceOpticalFlowImageFormatsNV fp_vkGetPhysicalDeviceOpticalFlowImageFormatsNV = nullptr; +#endif +#if (defined(VK_KHR_cooperative_matrix)) + PFN_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR fp_vkGetPhysicalDeviceCooperativeMatrixPropertiesKHR = nullptr; +#endif + bool is_populated() const { return populated; } + VkInstance instance = VK_NULL_HANDLE; +private: + bool populated = false; +}; + struct DispatchTable { DispatchTable() = default; DispatchTable(VkDevice device, PFN_vkGetDeviceProcAddr procAddr) : device(device), populated(true) { diff --git a/tests/bootstrap_tests.cpp b/tests/bootstrap_tests.cpp index f171b26..3fe7c9e 100644 --- a/tests/bootstrap_tests.cpp +++ b/tests/bootstrap_tests.cpp @@ -201,6 +201,11 @@ TEST_CASE("Select all Physical Devices", "[VkBootstrap.bootstrap]") { auto window = create_window_glfw("Select all Physical Devices"); auto instance = get_instance(1); + + auto instance_dispatch_table = instance.make_table(); + // needs to successfully create an instance dispatch table + REQUIRE(instance_dispatch_table.fp_vkEnumeratePhysicalDevices); + auto surface = create_surface_glfw(instance.instance, window); vkb::PhysicalDeviceSelector phys_device_selector(instance, surface); @@ -537,7 +542,7 @@ TEST_CASE("Querying Required Extension Features", "[VkBootstrap.select_features] } } -TEST_CASE("Passing vkb classes to Vulkan handles", "[VkBootstrap.pass_class_to_handle") { +TEST_CASE("Passing vkb classes to Vulkan handles", "[VkBootstrap.pass_class_to_handle]") { GIVEN("A working instance") { auto instance = get_instance();