From 1d073c02560cbb4e60741e543e4801f090a8534c Mon Sep 17 00:00:00 2001 From: Patrick Wuttke Date: Sat, 17 Sep 2022 16:42:55 +0200 Subject: [PATCH] Initial commit (should probably have done this earlier). --- .gitignore | 117 + .gitmodules | 3 + SConscript | 193 + VkLayer_capture.json | 14 + generators/common/__init__.py | 103 + generators/functions.cpp.py | 83 + generators/functions.hpp.py | 31 + generators/variant_wrap.hpp.py | 216 + generators/vk_function_ids.h.py | 45 + include/vk_capture.h | 112 + include/vk_function_ids.h | 457 + source/common.hpp | 39 + source/data_pool.cpp | 57 + source/data_pool.hpp | 50 + source/dispatch_table.cpp | 39 + source/dispatch_table.hpp | 38 + source/functions.cpp | 3518 ++++++ source/functions.hpp | 14 + source/layer.cpp | 164 + source/record_list.cpp | 94 + source/record_list.hpp | 87 + source/variant_pool.cpp | 50 + source/variant_pool.hpp | 146 + source/variant_wrap.hpp | 19673 ++++++++++++++++++++++++++++++ thirdparty/vulkan-docs | 1 + 25 files changed, 25344 insertions(+) create mode 100644 .gitmodules create mode 100644 SConscript create mode 100644 VkLayer_capture.json create mode 100644 generators/common/__init__.py create mode 100644 generators/functions.cpp.py create mode 100644 generators/functions.hpp.py create mode 100644 generators/variant_wrap.hpp.py create mode 100644 generators/vk_function_ids.h.py create mode 100644 include/vk_capture.h create mode 100644 include/vk_function_ids.h create mode 100644 source/common.hpp create mode 100644 source/data_pool.cpp create mode 100644 source/data_pool.hpp create mode 100644 source/dispatch_table.cpp create mode 100644 source/dispatch_table.hpp create mode 100644 source/functions.cpp create mode 100644 source/functions.hpp create mode 100644 source/layer.cpp create mode 100644 source/record_list.cpp create mode 100644 source/record_list.hpp create mode 100644 source/variant_pool.cpp create mode 100644 source/variant_pool.hpp create mode 100644 source/variant_wrap.hpp create mode 160000 thirdparty/vulkan-docs diff --git a/.gitignore b/.gitignore index e257658..50df34c 100644 --- a/.gitignore +++ b/.gitignore @@ -6,6 +6,7 @@ *.slo *.lo *.o +*.os *.obj # Precompiled Headers @@ -32,3 +33,119 @@ *.out *.app +# Byte-compiled / optimized / DLL files +__pycache__/ +*.py[cod] +*$py.class + +# C extensions +*.so + +# Distribution / packaging +.Python +build/ +develop-eggs/ +dist/ +downloads/ +eggs/ +.eggs/ +lib/ +lib64/ +parts/ +sdist/ +var/ +wheels/ +pip-wheel-metadata/ +share/python-wheels/ +*.egg-info/ +.installed.cfg +*.egg +MANIFEST + +# PyInstaller +# Usually these files are written by a python script from a template +# before PyInstaller builds the exe, so as to inject date/other infos into it. +*.manifest +*.spec + +# Installer logs +pip-log.txt +pip-delete-this-directory.txt + +# Unit test / coverage reports +htmlcov/ +.tox/ +.nox/ +.coverage +.coverage.* +.cache +nosetests.xml +coverage.xml +*.cover +.hypothesis/ +.pytest_cache/ + +# Translations +*.mo +*.pot + +# Django stuff: +*.log +local_settings.py +db.sqlite3 + +# Flask stuff: +instance/ +.webassets-cache + +# Scrapy stuff: +.scrapy + +# Sphinx documentation +docs/_build/ + +# PyBuilder +target/ + +# Jupyter Notebook +.ipynb_checkpoints + +# IPython +profile_default/ +ipython_config.py + +# pyenv +.python-version + +# celery beat schedule file +celerybeat-schedule + +# SageMath parsed files +*.sage.py + +# Environments +.env +.venv +env/ +venv/ +ENV/ +env.bak/ +venv.bak/ + +# Spyder project settings +.spyderproject +.spyproject + +# Rope project settings +.ropeproject + +# mkdocs documentation +/site + +# mypy +.mypy_cache/ +.dmypy.json +dmypy.json + +# Pyre type checker +.pyre/ diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..048b32c --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "vulkan-docs"] + path = thirdparty/vulkan-docs + url = https://github.com/KhronosGroup/Vulkan-Docs.git diff --git a/SConscript b/SConscript new file mode 100644 index 0000000..2d690de --- /dev/null +++ b/SConscript @@ -0,0 +1,193 @@ + +Import('env') +env = env.Clone() + +VK_FUNCTION_BLACKLIST = {'vkGetFramebufferTilePropertiesQCOM', 'vkGetDynamicRenderingTilePropertiesQCOM'} + +def parse_cmd_node(node, vulkan_hpp): + proto_tag = node.find('proto') + cmd_name = proto_tag and proto_tag.find('name').text or node.attrib.get('name', '') + if not cmd_name or cmd_name in VK_FUNCTION_BLACKLIST: + return + if proto_tag is None: + vulkan_hpp['commands'][node.attrib['name']] = { + 'name': node.attrib['name'], + 'alias': node.attrib['alias'], + 'extension': '', + 'platform': '' + } + return + type_tag = proto_tag.find('type') + name_tag = proto_tag.find('name') + + params = [] + for param_tag in node.findall('param'): + param_type_tag = param_tag.find('type') + param_name_tag = param_tag.find('name') + params.append({ + 'type': ((param_tag.text or "") + param_type_tag.text + (param_type_tag.tail or "")).strip(), + 'name': param_name_tag.text.strip(), + 'name_type_suffix': (param_name_tag.tail or "").strip() + }) + + vulkan_hpp['commands'][name_tag.text.strip()] = { + 'name': name_tag.text.strip(), + 'return_type': type_tag.text, + 'params': params, + 'extension': '', + 'platform': '' + } + +def parse_type_node(node, vulkan_hpp): + alias_for = node.attrib.get('alias') + type_name = node.attrib.get('name', '') + if alias_for is not None: + vulkan_hpp['types'][type_name] = { + 'name': type_name, + 'alias': alias_for, + 'extension': '', + 'platform': '' + } + return + category = node.attrib.get('category') + if category in ('struct', 'union'): + parse_struct_type_node(node, vulkan_hpp) + elif category == 'handle': + parse_handle_type_node(node, vulkan_hpp) + +def parse_struct_type_node(node, vulkan_hpp): + type_name = node.attrib['name'] + category = node.attrib.get('category') + + members = [] + sType = '' + for member_tag in node.findall('member'): + member_type_tag = member_tag.find('type') + member_name_tag = member_tag.find('name') + members.append({ + 'type': ((member_tag.text or "") + member_type_tag.text + (member_type_tag.tail or "")).strip(), + 'name': member_name_tag.text.strip(), + 'name_type_suffix': (member_name_tag.tail or "").strip(), + 'length': member_tag.attrib.get('len', '') + }) + if member_name_tag.text == 'sType': + sType = member_tag.attrib.get('values', '').split(',')[0] + vulkan_hpp['types'][type_name] = { + 'name': type_name, + 'category': category, + 'members': members, + 'sType': sType, + 'extension': '', + 'platform': '' + } + +def parse_handle_type_node(node, vulkan_hpp): + name_tag = node.find('name') + if name_tag is None: + return + type_name = name_tag.text + vulkan_hpp['types'][type_name] = { + 'name': type_name, + 'category': 'handle', + 'objtypeenum': node.attrib['objtypeenum'], + 'extension': '', + 'platform': '' + } + + +def parse_platform_node(platform_node, vulkan_hpp): + platform_name = platform_node.attrib['name'] + vulkan_hpp['platforms'][platform_name] = { + 'protect': platform_node.attrib['protect'] + } + +def parse_extension_node(extension_node, vulkan_hpp): + extension_name = extension_node.attrib['name'] + platform_name = extension_node.attrib.get('platform', '') + require_node = extension_node.find('require') + for cmd_node in require_node.findall('command'): + cmd_name = cmd_node.attrib['name'] + if cmd_name in vulkan_hpp['commands']: + vulkan_hpp['commands'][cmd_name]['extension'] = extension_name + vulkan_hpp['commands'][cmd_name]['platform'] = platform_name + for type_node in require_node.findall('type'): + type_name = type_node.attrib['name'] + if type_name in vulkan_hpp['types']: + vulkan_hpp['types'][type_name]['extension'] = extension_name + vulkan_hpp['types'][type_name]['platform'] = platform_name + vulkan_hpp['extensions'][extension_name] = { + 'platform': platform_name + } + +def parse_vulkan_hpp(): + import xml.etree.ElementTree as ET + + vulkan_hpp = { + 'commands': {}, + 'types': {}, + 'extensions': {}, + 'platforms': {} + } + + tree = ET.parse('thirdparty/vulkan-docs/xml/vk.xml') + root = tree.getroot() + + cmds_node = root.find('commands') + for cmd_node in cmds_node: + parse_cmd_node(cmd_node, vulkan_hpp) + + types_node = root.find('types') + for type_node in types_node: + parse_type_node(type_node, vulkan_hpp) + + platforms_node = root.find('platforms') + for platform_node in platforms_node: + parse_platform_node(platform_node, vulkan_hpp) + + extensions_node = root.find('extensions') + for extension_node in extensions_node: + parse_extension_node(extension_node, vulkan_hpp) + + return vulkan_hpp + +vulkan_hpp = parse_vulkan_hpp() + +def generate_source(target, source, env): + import os + import sys + from importlib.util import module_from_spec, spec_from_file_location + + # allow the module to import from its current folder + sys.path.append(os.path.dirname(source[0].abspath)) + python_spec = spec_from_file_location('source', source[0].abspath) + python_mod = module_from_spec(python_spec) + python_spec.loader.exec_module(python_mod) + python_mod.vulkan_hpp = vulkan_hpp + python_mod.generate(targets = [t.abspath for t in target]) + + # restore path + sys.path = sys.path[:-1] + + return None + +pygen_builder = Builder(action = generate_source) +env.Append(BUILDERS = {'PyGen': pygen_builder}) +env.Append(CPPPATH = ['include']) + +source_files = Split(""" + source/data_pool.cpp + source/dispatch_table.cpp + source/functions.cpp + source/layer.cpp + source/record_list.cpp + source/variant_pool.cpp +""") + +# env.PyGen('source/functions.hpp', 'generators/functions.hpp.py') +env.PyGen('include/vk_function_ids.h', 'generators/vk_function_ids.h.py') +env.PyGen('source/functions.cpp', 'generators/functions.cpp.py') +env.PyGen('source/variant_wrap.hpp', 'generators/variant_wrap.hpp.py') +env.SharedLibrary( + target = 'VkLayer_capture', + source = source_files +) diff --git a/VkLayer_capture.json b/VkLayer_capture.json new file mode 100644 index 0000000..9931f5b --- /dev/null +++ b/VkLayer_capture.json @@ -0,0 +1,14 @@ +{ + "file_format_version": "1.2.0", + "layer": { + "name": "VK_LAYER_MEWIN_capture", + "type": "GLOBAL", + "library_path": "./libVkLayer_capture.so", + "api_version": "1.3.221", + "implementation_version": "1", + "description": "Layer for capturing Vulkan commands", + "functions": { + "vkNegotiateLoaderLayerInterfaceVersion": "vk_capture_vkNegotiateLoaderLayerInterfaceVersion" + } + } +} diff --git a/generators/common/__init__.py b/generators/common/__init__.py new file mode 100644 index 0000000..1ea2a40 --- /dev/null +++ b/generators/common/__init__.py @@ -0,0 +1,103 @@ + +FIRST_PARAM_BLACKLIST = {'VkInstance', 'VkPhysicalDevice'} + +FUNC_BLACKLIST = {'vkCreateInstance', 'vkDestroyInstance', 'vkGetDeviceProcAddr', 'vkDestroyDevice', 'vkEnumerateInstanceVersion', + 'vkEnumerateInstanceLayerProperties', 'vkEnumerateInstanceExtensionProperties', 'vkCmdDrawMeshTasksEXT', + 'vkCmdDrawMeshTasksIndirectEXT', 'vkCmdDrawMeshTasksIndirectCountEXT', 'vkGetDeviceGroupSurfacePresentModes2EXT', + 'vkGetShaderModuleIdentifierEXT', 'vkGetShaderModuleCreateInfoIdentifierEXT'} + +# TODO: some of these could probably be handled better if I parsed the xml file correctly ... +TYPE_BLACKLIST = {'VkPhysicalDeviceMeshShaderFeaturesEXT', 'VkPhysicalDeviceMeshShaderPropertiesEXT', + 'VkSurfaceFullScreenExclusiveWin32InfoEXT', 'VkPhysicalDeviceLegacyDitheringFeaturesEXT', + 'VkAndroidHardwareBufferFormatProperties2ANDROID', 'VkPhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT', + 'VkImageViewSampleWeightCreateInfoQCOM', 'VkPhysicalDeviceImageProcessingFeaturesQCOM', + 'VkPhysicalDeviceImageProcessingPropertiesQCOM', 'VkPhysicalDeviceTilePropertiesFeaturesQCOM', 'VkTilePropertiesQCOM', + 'VkPhysicalDeviceAmigoProfilingFeaturesSEC', 'VkAmigoProfilingSubmitInfoSEC', + 'VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT', 'VkPhysicalDeviceDepthClampZeroOneFeaturesEXT', + 'VkDrawMeshTasksIndirectCommandEXT'} + +def func_name_to_caps(name): + assert(name[0:2] == "vk") + caps = [name[2]] + wasupper = True + for char in name[3:]: + if char.isupper(): + if not wasupper: + caps.append("_") + wasupper = True + else: + wasupper = False + caps.append(char.upper()) + return "".join(caps) + +STRUCT_NAME_EXCEPTIONS = { + 'VkPhysicalDeviceIDProperties': 'VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES' +} + +def struct_name_to_enum(name): + assert(name[0:2] == "Vk") + exception = name in STRUCT_NAME_EXCEPTIONS + if exception: + return exception + caps = ["VK_STRUCTURE_TYPE_", name[2]] + wasupper = True + wasnumeric = False + for char in name[3:]: + if char.isupper(): + if not wasupper: + caps.append("_") + wasupper = True + else: + wasupper = False + if char.isnumeric(): + if not wasnumeric: + caps.append("_") + wasnumeric = True + else: + wasnumeric = False + caps.append(char.upper()) + return "".join(caps) + +def write_preamble(f, header_guard = None, includes = [], c_file = False): + f.write(""" +// This file has been automatically generated. Do NOT edit edit manually, all your changes will be lost when it is regenerated. +""") + if header_guard is not None: + f.write(f""" +#pragma once + +#if !defined({header_guard}) +#define {header_guard} 1 +""") + + for include in includes: + f.write(f""" +#include {include}""") + + if c_file: + f.write(""" +#if defined(__cplusplus) +extern "C" { +#endif +""") + else: + f.write(""" +namespace vk_capture +{ +""") + +def write_epilogue(f, header_guard = None, c_file = False): + if c_file: + f.write(""" +#if defined(__cplusplus) +} // extern "C" +#endif +""") + else: + f.write(""" +} // namespace vk_capture +""") + if header_guard is not None: + f.write(f""" +#endif // {header_guard} +""") diff --git a/generators/functions.cpp.py b/generators/functions.cpp.py new file mode 100644 index 0000000..d18dce3 --- /dev/null +++ b/generators/functions.cpp.py @@ -0,0 +1,83 @@ + +from common import func_name_to_caps, write_epilogue, write_preamble, FIRST_PARAM_BLACKLIST, FUNC_BLACKLIST + +def write_funcdef(f, cmd): + if 'alias' in cmd or cmd["name"] in FUNC_BLACKLIST: + return + if len(cmd['params']) > 0 and cmd['params'][0]['type'] in FIRST_PARAM_BLACKLIST: + return + f.write(f"""{cmd["return_type"]} {cmd["name"]}(""") + f.write(", ".join([f"""{p['type']} {p['name']}{p['name_type_suffix']}""" for p in cmd['params']])) + + func_name = f"VK_FUNCTION_{func_name_to_caps(cmd['name'])}_MWN" + param_list_pass = ", ".join([f"""{p['name']}""" for p in cmd['params']]) + if cmd['return_type'] == 'void': + f.write(f""") +{{ + g_dispatchTable.{cmd["name"][2:]}({param_list_pass}); + recordVoidFunction({func_name}, {param_list_pass}); +}} +""") + else: + f.write(f""") +{{ + auto result = g_dispatchTable.{cmd["name"][2:]}({param_list_pass}); + recordFunction({func_name}, result, {param_list_pass}); + return result; +}} +""") + +def write_funcgetter(f, cmd, alias_for = ''): + if cmd["name"] in FUNC_BLACKLIST: + return + if 'alias' in cmd: + write_funcgetter(f, vulkan_hpp['commands'][cmd['alias']], alias_for=cmd['name']) + return + if len(cmd['params']) > 0 and cmd['params'][0]['type'] in FIRST_PARAM_BLACKLIST: + return + f.write(f""" + if (std::strcmp(pName, "{alias_for or cmd['name']}") == 0) {{ + return reinterpret_cast(&{cmd['name']}); + }} else""") + +def generate(targets): + assert(len(targets) == 1) + with open(targets[0], 'w') as f: + write_preamble(f, includes = ['', '"dispatch_table.hpp"', '"functions.hpp"', '"record_list.hpp"', '"vk_function_ids.h"']) + commands = list(vulkan_hpp['commands'].values()) + commands.sort(key=lambda cmd: cmd['platform']) + plat = '' + for cmd in commands: + if plat != cmd['platform']: + if plat != '': + f.write(f""" +#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + plat = cmd['platform'] + f.write(f""" +#if defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + write_funcdef(f, cmd) + # finish the final platform + f.write(f"""#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + + f.write("""PFN_vkVoidFunction getWrappedFunctionPtr(const char* pName) +{ + """) + plat = '' + for cmd in commands: + if plat != cmd['platform']: + if plat != '': + f.write(f""" +#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + plat = cmd['platform'] + f.write(f""" +#if defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + write_funcgetter(f, cmd) + # finish the final platform + f.write(f""" +#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + f.write(""" + {{ + return nullptr; + }} +}""") + write_epilogue(f) diff --git a/generators/functions.hpp.py b/generators/functions.hpp.py new file mode 100644 index 0000000..1633dc9 --- /dev/null +++ b/generators/functions.hpp.py @@ -0,0 +1,31 @@ + +from common import write_epilogue, write_preamble, FUNC_BLACKLIST + +HEADER_GUARD = 'VK_CAPTURE_FUNCTIONS_HPP_INCLUDED' + +def write_funcsig(f, cmd): + if 'alias' in cmd or cmd["name"] in FUNC_BLACKLIST: + return + if len(cmd['params']) > 0 and cmd['params'][0]['type'] in ('VkInstance', 'VkPhysicalDevice'): + return + f.write(f"""{cmd["return_type"]} {cmd["name"]}(""") + f.write(", ".join([f"""{p['type']} {p['name']}{p['name_type_suffix']}""" for p in cmd['params']])) + f.write(");\n") + +def generate(targets): + assert(len(targets) == 1) + with open(targets[0], 'w') as f: + write_preamble(f, header_guard=HEADER_GUARD, includes = ['']) + # commands = list(vulkan_hpp['commands'].values()) + # commands.sort(key=lambda cmd: cmd['platform']) + # plat = '' + # for cmd in commands: + # if plat != cmd['platform']: + # if plat != '': + # f.write(f"""#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + # plat = cmd['platform'] + # f.write(f"""#if defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + # write_funcsig(f, cmd) + # # finish the final platform + # f.write(f"""#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + write_epilogue(f, header_guard=HEADER_GUARD) diff --git a/generators/variant_wrap.hpp.py b/generators/variant_wrap.hpp.py new file mode 100644 index 0000000..b0024bc --- /dev/null +++ b/generators/variant_wrap.hpp.py @@ -0,0 +1,216 @@ +import binascii +from common import struct_name_to_enum, write_epilogue, write_preamble, FIRST_PARAM_BLACKLIST, TYPE_BLACKLIST + +HEADER_GUARD = 'VK_CAPTURE_VARIANT_WRAP_HPP_INCLUDED' + +LENGTH_EXCEPTIONS = { + ('VkShaderModuleCreateInfo', 'pCode'): 'value.codeSize / 4', + ('VkPipelineMultisampleStateCreateInfo', 'pSampleMask'): '(value.rasterizationSamples + 31) / 32', + ('VkAccelerationStructureVersionInfoKHR', 'pVersionData'): '2 * VK_UUID_SIZE' +} + +def write_copyfunc_definition(f, struct): + if 'alias' in struct or struct['name'] in TYPE_BLACKLIST or struct['category'] != 'struct': + return + f.write(f"""inline void copyIndirectData({struct['name']}& value); +""") + + +def write_copyfunc(f, struct): + if 'alias' in struct or struct['name'] in TYPE_BLACKLIST or struct['category'] != 'struct': + return + f.write(f""" +inline void copyIndirectData([[maybe_unused]] {struct['name']}& value) +{{""") + for member in struct['members']: + if 'void*' in member['type']: + if member['name'] == 'pNext': + f.write(""" + value.pNext = copyNextPtr(value.pNext);""") + continue + if member['type'].endswith('**'): + pass + elif member['type'].endswith('*'): + f.write(f""" + if (value.{member['name']} != nullptr) + {{ + using base_type_t = std::decay_t<{member['type'].strip('*')}>;""") + length_exception = LENGTH_EXCEPTIONS.get((struct['name'], member['name'])) + if length_exception: + f.write(f""" + const std::size_t numElements = {length_exception}; + """) + elif member['type'].endswith('char*'): + f.write(f""" + const std::size_t numElements = std::strlen(value.{member['name']}) + 1;""") + elif member['length']: + f.write(f""" + const std::size_t numElements = value.{member['length'].split(',')[0]};""") + else: + f.write(f""" + static constexpr std::size_t numElements = 1; // TODO""") + f.write(f""" + auto copy = allocType(numElements); + std::memcpy(copy, value.{member['name']}, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) {{ + copyIndirectData(copy[ele]); + }} + value.{member['name']} = copy; + }} +""") + f.write(f""" +}} +""") + +def write_structwrapper(f, struct): + if 'alias' in struct or struct['name'] in TYPE_BLACKLIST: + return + if(len(struct['members']) < 2 or struct['members'][1]['name'] != 'pNext'): + return # TODO + is_output = "const" not in struct['members'][1]['type'] + f.write(f""" +inline void variantWrap(const {struct['name']}& value, VkVariantMWN& outVariant) +{{ + outVariant.type = VK_VARIANT_TYPE_{is_output and "OUT" or "IN"}_STRUCTURE_MWN; + + auto valueCopy = allocType<{struct['name']}>(); + outVariant.{is_output and "out" or "in"}StructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof({struct['name']})); + copyIndirectData(*valueCopy); +}} +""") + +def write_handlewrapper(f, handle): + if 'alias' in handle or handle['name'] in TYPE_BLACKLIST: + return + f.write(f""" +inline void variantWrap({handle['name']} value, VkVariantMWN& outVariant) +{{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = {handle['objtypeenum']}; + outVariant.objectValue.value = value; +}} +""") + +def write_nextptrcase(f, struct): + if 'alias' in struct or struct['name'] in TYPE_BLACKLIST or struct['name'] in ('VkBaseOutStructure', 'VkBaseInStructure'): + return + if(len(struct['members']) < 2 or struct['members'][0]['name'] != 'sType'): + return + f.write(f""" + case {(struct['sType'])}: + pCopy = allocType<{struct['name']}>(); + std::memcpy(pCopy, pNext, sizeof({struct['name']})); + copyIndirectData(*static_cast<{struct['name']}*>(pCopy)); + break;""") + +def generate(targets): + assert(len(targets) == 1) + with open(targets[0], 'w') as f: + write_preamble(f, includes = ['', '', '', '"common.hpp"', '"vk_capture.h"'], header_guard=HEADER_GUARD) + + f.write(""" +inline void* copyNextPtr(const void* pNext); + +// do nothing by default +template +inline void copyIndirectData(const T&) {} + +inline void copyIndirectData(const char*& value) +{ + const std::size_t len = std::strlen(value) + 1; + char* copy = allocType(len); + std::memcpy(copy, value, len); + value = copy; +} + +template +inline void copyIndirectData(const TStruct*& value) +{ + TStruct* copy = allocType(); + std::memcpy(copy, value, sizeof(TStruct)); + copyIndirectData(*copy); + value = copy; +} +""") + + types = list(vulkan_hpp['types'].values()) + types.sort(key=lambda tp: tp['platform']) + plat = '' + for tp in types: + if plat != tp['platform']: + if plat != '': + f.write(f""" +#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + plat = tp['platform'] + f.write(f""" +#if defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + if tp.get('category') in ('struct', 'union'): + write_copyfunc_definition(f, tp) + # finish the final platform + f.write(f"""#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + + plat = '' + for tp in types: + if plat != tp['platform']: + if plat != '': + f.write(f""" +#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + plat = tp['platform'] + f.write(f""" +#if defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + if tp.get('category') in ('struct', 'union'): + write_copyfunc(f, tp) + # finish the final platform + f.write(f"""#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + + plat = '' + for tp in types: + if plat != tp['platform']: + if plat != '': + f.write(f""" +#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + plat = tp['platform'] + f.write(f""" +#if defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + if tp.get('category') in ('struct', 'union'): + write_structwrapper(f, tp) + elif tp.get('category') == 'handle': + write_handlewrapper(f, tp) + # finish the final platform + f.write(f""" +#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + + f.write(""" +inline void* copyNextPtr(const void* pNext) +{ + if (pNext == nullptr) { + return nullptr; + } + const VkStructureType sType = *static_cast(pNext); + void* pCopy = nullptr; + switch (sType) + {""") + plat = '' + for tp in types: + if plat != tp['platform']: + if plat != '': + f.write(f""" +#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + plat = tp['platform'] + f.write(f""" +#if defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + if tp.get('category') in ('struct', 'union'): + write_nextptrcase(f, tp) + # finish the final platform + f.write(f""" +#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + f.write(""" + default: break; + } + return pCopy; +}""") + + write_epilogue(f, header_guard=HEADER_GUARD) diff --git a/generators/vk_function_ids.h.py b/generators/vk_function_ids.h.py new file mode 100644 index 0000000..7ed5ca2 --- /dev/null +++ b/generators/vk_function_ids.h.py @@ -0,0 +1,45 @@ +import binascii +from common import func_name_to_caps, write_epilogue, write_preamble, FIRST_PARAM_BLACKLIST, FUNC_BLACKLIST + +HEADER_GUARD = 'VK_CAPTURE_FUNCTION_IDS_H_INCLUDED' +_dbg_hashes = set() + + +def write_funcid(f, cmd): + if 'alias' in cmd or cmd["name"] in FUNC_BLACKLIST: + return + if len(cmd['params']) > 0 and cmd['params'][0]['type'] in FIRST_PARAM_BLACKLIST: + return + funchash = binascii.crc32(cmd['name'].encode('utf8')) + f.write(f""" + VK_FUNCTION_{func_name_to_caps(cmd['name'])}_MWN = {funchash},""") + + # just to make sure there are no hash collisions, we wouldn't want that + global _dbg_hashes + assert(funchash not in _dbg_hashes) + _dbg_hashes.add(funchash) + +def generate(targets): + assert(len(targets) == 1) + with open(targets[0], 'w') as f: + write_preamble(f, includes = [''], header_guard=HEADER_GUARD, c_file=True) + commands = list(vulkan_hpp['commands'].values()) + commands.sort(key=lambda cmd: cmd['platform']) + plat = '' + f.write(""" +typedef enum VkFunctionMWN {""") + for cmd in commands: + if plat != cmd['platform']: + if plat != '': + f.write(f""" +#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + plat = cmd['platform'] + f.write(f""" +#if defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + write_funcid(f, cmd) + # finish the final platform + f.write(f"""#endif // defined({vulkan_hpp['platforms'][plat]['protect']})\n""") + f.write(""" +} VkFunctionMWN; +""") + write_epilogue(f, header_guard=HEADER_GUARD, c_file=True) diff --git a/include/vk_capture.h b/include/vk_capture.h new file mode 100644 index 0000000..7a47463 --- /dev/null +++ b/include/vk_capture.h @@ -0,0 +1,112 @@ + +#if !defined(VK_CAPTURE_H_INCLUDED) +#define VK_CAPTURE_H_INCLUDED 1 + +#include +#include "vk_function_ids.h" + +#if defined(__cplusplus) +extern "C" { +#endif + +VK_DEFINE_HANDLE(VkRecordListMWN); + +static const VkStructureType VK_STRUCTURE_TYPE_RECORD_LIST_ALLOCATE_INFO_MWN = (VkStructureType) 2000144777; // pretty random, but should be fine I guess +static const VkStructureType VK_STRUCTURE_TYPE_RECORD_INFO_MWN = (VkStructureType) 2000144778; + +typedef enum VkRecordListAllocateFlagBitsMWN { + VK_RECORD_LIST_ALLOCATE_FLAG_BITS_NONE_MWN = 0, + VK_RECORD_LIST_ALLOCATE_FLAG_BITS_MAX_ENUM_MWN = 0x7FFFFFFF +} VkRecordListAllocateFlagBitsMWN; +typedef VkFlags VkRecordListAllocateFlagsMWN; + +typedef enum VkRecordFlagBitsMWN { + VK_RECORD_FLAG_BITS_NONE_MWN = 0, + VK_RECORD_FLAG_BITS_MAX_ENUM_MWN = 0x7FFFFFFF +} VkRecordFlagBitsMWN; +typedef VkFlags VkRecordFlags; + +typedef struct VkRecordListAllocateInfoMWN +{ + VkStructureType sType; + void* pNext; + VkRecordListAllocateFlagsMWN flags; +} VkRecordListAllocateInfoMWN; + +typedef struct VkRecordInfoMWN +{ + VkStructureType sType; + void* pNext; + VkRecordFlags flags; + VkRecordListMWN recordList; +} VkRecordInfoMWN; + +typedef enum VkVariantTypeMWN { + VK_VARIANT_TYPE_UNKNOWN_MWN = 0, + VK_VARIANT_TYPE_NONE_MWN = 1, + VK_VARIANT_TYPE_BOOL_MWN = 2, + VK_VARIANT_TYPE_UINT8_MWN = 3, + VK_VARIANT_TYPE_INT8_MWN = 4, + VK_VARIANT_TYPE_UINT16_MWN = 5, + VK_VARIANT_TYPE_INT16_MWN = 6, + VK_VARIANT_TYPE_UINT32_MWN = 7, + VK_VARIANT_TYPE_INT32_MWN = 8, + VK_VARIANT_TYPE_UINT64_MWN = 9, + VK_VARIANT_TYPE_INT64_MWN = 10, + VK_VARIANT_TYPE_FLOAT_MWN = 11, + VK_VARIANT_TYPE_DOUBLE_MWN = 12, + VK_VARIANT_TYPE_STRING_MWN = 13, + VK_VARIANT_TYPE_VOID_POINTER_MWN = 14, + VK_VARIANT_TYPE_POINTER_MWN = 15, + VK_VARIANT_TYPE_ARRAY_MWN = 16, + VK_VARIANT_TYPE_IN_STRUCTURE_MWN = 17, + VK_VARIANT_TYPE_OUT_STRUCTURE_MWN = 18, + VK_VARIANT_TYPE_OBJECT_MWN = 19 +} VkVariantTypeMWN; + +typedef struct VkVariantObjectValueMWN { + void* value; + VkObjectType type; +} VkVariantObjectValueMWN; + +typedef struct VkVariantArrayValueMWN { + size_t numElements; + struct VkVariantMWN* elements; +} VkVariantArrayValueMWN; + +typedef struct VkVariantMWN { + VkVariantTypeMWN type; + union + { + uint64_t uintValue; + int64_t intValue; + float floatValue; + double doubleValue; + const void* voidPointerValue; + VkVariantMWN* pointerValue; + VkVariantArrayValueMWN arrayValue; + VkBaseInStructure* inStructureValue; + VkBaseOutStructure* outStructureValue; + VkVariantObjectValueMWN objectValue; + }; +} VkVariantMWN; + +typedef struct VkRecordListItemMWN +{ + VkFunctionMWN function; + VkVariantMWN returnValue; + uint32_t numParameters; + VkVariantMWN* pParameterValues; +} VkRecordListItemMWN; + +typedef VkResult (VKAPI_PTR *PFN_vkAllocateRecordListMWN)(VkDevice device, const VkRecordListAllocateInfoMWN* pCreateInfo, VkRecordListMWN* pRecordList); +typedef void (VKAPI_PTR *PFN_vkFreeRecordListMWN)(VkDevice device, VkRecordListMWN recordList); +typedef VkResult (VKAPI_PTR *PFN_vkBeginRecordingMWN)(VkDevice device, const VkRecordInfoMWN* pRecordInfo); +typedef void (VKAPI_PTR *PFN_vkEndRecordingMWN)(VkDevice device); +typedef VkResult (VKAPI_PTR *PFN_vkGetRecordListItemsMWN)(VkDevice device, VkRecordListMWN recordList, uint32_t* pItemCount, VkRecordListItemMWN** pItems); + +#if defined(__cplusplus) +} // extern "C" +#endif + +#endif //VK_CAPTURE_H_INCLUDED diff --git a/include/vk_function_ids.h b/include/vk_function_ids.h new file mode 100644 index 0000000..b4971e8 --- /dev/null +++ b/include/vk_function_ids.h @@ -0,0 +1,457 @@ + +// This file has been automatically generated. Do NOT edit edit manually, all your changes will be lost when it is regenerated. + +#pragma once + +#if !defined(VK_CAPTURE_FUNCTION_IDS_H_INCLUDED) +#define VK_CAPTURE_FUNCTION_IDS_H_INCLUDED 1 + +#include +#if defined(__cplusplus) +extern "C" { +#endif + +typedef enum VkFunctionMWN { + VK_FUNCTION_GET_DEVICE_QUEUE_MWN = 1801008959, + VK_FUNCTION_QUEUE_SUBMIT_MWN = 1197493870, + VK_FUNCTION_QUEUE_WAIT_IDLE_MWN = 1940615428, + VK_FUNCTION_DEVICE_WAIT_IDLE_MWN = 2002580487, + VK_FUNCTION_ALLOCATE_MEMORY_MWN = 2253521660, + VK_FUNCTION_FREE_MEMORY_MWN = 2468360846, + VK_FUNCTION_MAP_MEMORY_MWN = 3621835301, + VK_FUNCTION_UNMAP_MEMORY_MWN = 2338647589, + VK_FUNCTION_FLUSH_MAPPED_MEMORY_RANGES_MWN = 3558031893, + VK_FUNCTION_INVALIDATE_MAPPED_MEMORY_RANGES_MWN = 2887142980, + VK_FUNCTION_GET_DEVICE_MEMORY_COMMITMENT_MWN = 334806908, + VK_FUNCTION_GET_BUFFER_MEMORY_REQUIREMENTS_MWN = 3036355670, + VK_FUNCTION_BIND_BUFFER_MEMORY_MWN = 1840048986, + VK_FUNCTION_GET_IMAGE_MEMORY_REQUIREMENTS_MWN = 2835363504, + VK_FUNCTION_BIND_IMAGE_MEMORY_MWN = 1810199277, + VK_FUNCTION_GET_IMAGE_SPARSE_MEMORY_REQUIREMENTS_MWN = 1578405834, + VK_FUNCTION_QUEUE_BIND_SPARSE_MWN = 4028062444, + VK_FUNCTION_CREATE_FENCE_MWN = 1360193736, + VK_FUNCTION_DESTROY_FENCE_MWN = 3713526231, + VK_FUNCTION_RESET_FENCES_MWN = 3666245786, + VK_FUNCTION_GET_FENCE_STATUS_MWN = 997506943, + VK_FUNCTION_WAIT_FOR_FENCES_MWN = 875329429, + VK_FUNCTION_CREATE_SEMAPHORE_MWN = 4268486740, + VK_FUNCTION_DESTROY_SEMAPHORE_MWN = 2664671713, + VK_FUNCTION_CREATE_EVENT_MWN = 2270550839, + VK_FUNCTION_DESTROY_EVENT_MWN = 185653800, + VK_FUNCTION_GET_EVENT_STATUS_MWN = 3069640675, + VK_FUNCTION_SET_EVENT_MWN = 1748142302, + VK_FUNCTION_RESET_EVENT_MWN = 1072499137, + VK_FUNCTION_CREATE_QUERY_POOL_MWN = 2763305260, + VK_FUNCTION_DESTROY_QUERY_POOL_MWN = 3289180313, + VK_FUNCTION_GET_QUERY_POOL_RESULTS_MWN = 945300247, + VK_FUNCTION_RESET_QUERY_POOL_MWN = 1611793927, + VK_FUNCTION_CREATE_BUFFER_MWN = 3253311591, + VK_FUNCTION_DESTROY_BUFFER_MWN = 1282265235, + VK_FUNCTION_CREATE_BUFFER_VIEW_MWN = 1759615169, + VK_FUNCTION_DESTROY_BUFFER_VIEW_MWN = 3549063067, + VK_FUNCTION_CREATE_IMAGE_MWN = 2043073999, + VK_FUNCTION_DESTROY_IMAGE_MWN = 4119057616, + VK_FUNCTION_GET_IMAGE_SUBRESOURCE_LAYOUT_MWN = 2510335218, + VK_FUNCTION_CREATE_IMAGE_VIEW_MWN = 1339733099, + VK_FUNCTION_DESTROY_IMAGE_VIEW_MWN = 795012574, + VK_FUNCTION_CREATE_SHADER_MODULE_MWN = 4209023304, + VK_FUNCTION_DESTROY_SHADER_MODULE_MWN = 2545318000, + VK_FUNCTION_CREATE_PIPELINE_CACHE_MWN = 4045836824, + VK_FUNCTION_DESTROY_PIPELINE_CACHE_MWN = 3645471847, + VK_FUNCTION_GET_PIPELINE_CACHE_DATA_MWN = 593534222, + VK_FUNCTION_MERGE_PIPELINE_CACHES_MWN = 3775278370, + VK_FUNCTION_CREATE_GRAPHICS_PIPELINES_MWN = 2193739499, + VK_FUNCTION_CREATE_COMPUTE_PIPELINES_MWN = 3526437674, + VK_FUNCTION_GET_DEVICE_SUBPASS_SHADING_MAX_WORKGROUP_SIZE_HUAWEI_MWN = 129736554, + VK_FUNCTION_DESTROY_PIPELINE_MWN = 980737728, + VK_FUNCTION_CREATE_PIPELINE_LAYOUT_MWN = 394847638, + VK_FUNCTION_DESTROY_PIPELINE_LAYOUT_MWN = 3608864469, + VK_FUNCTION_CREATE_SAMPLER_MWN = 3993023298, + VK_FUNCTION_DESTROY_SAMPLER_MWN = 1415381263, + VK_FUNCTION_CREATE_DESCRIPTOR_SET_LAYOUT_MWN = 3936216980, + VK_FUNCTION_DESTROY_DESCRIPTOR_SET_LAYOUT_MWN = 3524710707, + VK_FUNCTION_CREATE_DESCRIPTOR_POOL_MWN = 620489314, + VK_FUNCTION_DESTROY_DESCRIPTOR_POOL_MWN = 3832146209, + VK_FUNCTION_RESET_DESCRIPTOR_POOL_MWN = 1613541836, + VK_FUNCTION_ALLOCATE_DESCRIPTOR_SETS_MWN = 318794980, + VK_FUNCTION_FREE_DESCRIPTOR_SETS_MWN = 3153914723, + VK_FUNCTION_UPDATE_DESCRIPTOR_SETS_MWN = 3773071573, + VK_FUNCTION_CREATE_FRAMEBUFFER_MWN = 1282047188, + VK_FUNCTION_DESTROY_FRAMEBUFFER_MWN = 3345985473, + VK_FUNCTION_CREATE_RENDER_PASS_MWN = 2541235822, + VK_FUNCTION_DESTROY_RENDER_PASS_MWN = 739496244, + VK_FUNCTION_GET_RENDER_AREA_GRANULARITY_MWN = 378226644, + VK_FUNCTION_CREATE_COMMAND_POOL_MWN = 220543643, + VK_FUNCTION_DESTROY_COMMAND_POOL_MWN = 2250303886, + VK_FUNCTION_RESET_COMMAND_POOL_MWN = 777004411, + VK_FUNCTION_ALLOCATE_COMMAND_BUFFERS_MWN = 3338007255, + VK_FUNCTION_FREE_COMMAND_BUFFERS_MWN = 1846113616, + VK_FUNCTION_BEGIN_COMMAND_BUFFER_MWN = 2575515866, + VK_FUNCTION_END_COMMAND_BUFFER_MWN = 2602013632, + VK_FUNCTION_RESET_COMMAND_BUFFER_MWN = 1950753224, + VK_FUNCTION_CMD_BIND_PIPELINE_MWN = 2681631005, + VK_FUNCTION_CMD_SET_VIEWPORT_MWN = 611416209, + VK_FUNCTION_CMD_SET_SCISSOR_MWN = 1908838255, + VK_FUNCTION_CMD_SET_LINE_WIDTH_MWN = 764516546, + VK_FUNCTION_CMD_SET_DEPTH_BIAS_MWN = 3754402555, + VK_FUNCTION_CMD_SET_BLEND_CONSTANTS_MWN = 1508866211, + VK_FUNCTION_CMD_SET_DEPTH_BOUNDS_MWN = 34716900, + VK_FUNCTION_CMD_SET_STENCIL_COMPARE_MASK_MWN = 3047889784, + VK_FUNCTION_CMD_SET_STENCIL_WRITE_MASK_MWN = 2182897628, + VK_FUNCTION_CMD_SET_STENCIL_REFERENCE_MWN = 2438412126, + VK_FUNCTION_CMD_BIND_DESCRIPTOR_SETS_MWN = 3144895685, + VK_FUNCTION_CMD_BIND_INDEX_BUFFER_MWN = 1707366535, + VK_FUNCTION_CMD_BIND_VERTEX_BUFFERS_MWN = 1119662941, + VK_FUNCTION_CMD_DRAW_MWN = 3029237212, + VK_FUNCTION_CMD_DRAW_INDEXED_MWN = 1374024729, + VK_FUNCTION_CMD_DRAW_MULTI_EXT_MWN = 694534688, + VK_FUNCTION_CMD_DRAW_MULTI_INDEXED_EXT_MWN = 4087296610, + VK_FUNCTION_CMD_DRAW_INDIRECT_MWN = 73174078, + VK_FUNCTION_CMD_DRAW_INDEXED_INDIRECT_MWN = 2845039994, + VK_FUNCTION_CMD_DISPATCH_MWN = 1021302334, + VK_FUNCTION_CMD_DISPATCH_INDIRECT_MWN = 3326151095, + VK_FUNCTION_CMD_SUBPASS_SHADING_HUAWEI_MWN = 4007053037, + VK_FUNCTION_CMD_COPY_BUFFER_MWN = 3269750429, + VK_FUNCTION_CMD_COPY_IMAGE_MWN = 3268551501, + VK_FUNCTION_CMD_BLIT_IMAGE_MWN = 369031726, + VK_FUNCTION_CMD_COPY_BUFFER_TO_IMAGE_MWN = 3430632791, + VK_FUNCTION_CMD_COPY_IMAGE_TO_BUFFER_MWN = 3463100572, + VK_FUNCTION_CMD_UPDATE_BUFFER_MWN = 4166030863, + VK_FUNCTION_CMD_FILL_BUFFER_MWN = 1227180894, + VK_FUNCTION_CMD_CLEAR_COLOR_IMAGE_MWN = 2860344020, + VK_FUNCTION_CMD_CLEAR_DEPTH_STENCIL_IMAGE_MWN = 626607859, + VK_FUNCTION_CMD_CLEAR_ATTACHMENTS_MWN = 3248052992, + VK_FUNCTION_CMD_RESOLVE_IMAGE_MWN = 3127045135, + VK_FUNCTION_CMD_SET_EVENT_MWN = 2285897557, + VK_FUNCTION_CMD_RESET_EVENT_MWN = 2593994370, + VK_FUNCTION_CMD_WAIT_EVENTS_MWN = 1151170789, + VK_FUNCTION_CMD_PIPELINE_BARRIER_MWN = 930214991, + VK_FUNCTION_CMD_BEGIN_QUERY_MWN = 1060928638, + VK_FUNCTION_CMD_END_QUERY_MWN = 743888596, + VK_FUNCTION_CMD_BEGIN_CONDITIONAL_RENDERING_EXT_MWN = 635529039, + VK_FUNCTION_CMD_END_CONDITIONAL_RENDERING_EXT_MWN = 4205254823, + VK_FUNCTION_CMD_RESET_QUERY_POOL_MWN = 1325891048, + VK_FUNCTION_CMD_WRITE_TIMESTAMP_MWN = 1176332583, + VK_FUNCTION_CMD_COPY_QUERY_POOL_RESULTS_MWN = 3870607162, + VK_FUNCTION_CMD_PUSH_CONSTANTS_MWN = 2905672087, + VK_FUNCTION_CMD_BEGIN_RENDER_PASS_MWN = 1913985478, + VK_FUNCTION_CMD_NEXT_SUBPASS_MWN = 911216383, + VK_FUNCTION_CMD_END_RENDER_PASS_MWN = 1325099252, + VK_FUNCTION_CMD_EXECUTE_COMMANDS_MWN = 1434241781, + VK_FUNCTION_CREATE_SHARED_SWAPCHAINS_KHR_MWN = 833058384, + VK_FUNCTION_CREATE_SWAPCHAIN_KHR_MWN = 3291491461, + VK_FUNCTION_DESTROY_SWAPCHAIN_KHR_MWN = 2842086845, + VK_FUNCTION_GET_SWAPCHAIN_IMAGES_KHR_MWN = 3820567199, + VK_FUNCTION_ACQUIRE_NEXT_IMAGE_KHR_MWN = 912430364, + VK_FUNCTION_QUEUE_PRESENT_KHR_MWN = 3343619925, + VK_FUNCTION_DEBUG_MARKER_SET_OBJECT_NAME_EXT_MWN = 2629627847, + VK_FUNCTION_DEBUG_MARKER_SET_OBJECT_TAG_EXT_MWN = 3118774776, + VK_FUNCTION_CMD_DEBUG_MARKER_BEGIN_EXT_MWN = 391248749, + VK_FUNCTION_CMD_DEBUG_MARKER_END_EXT_MWN = 3909749052, + VK_FUNCTION_CMD_DEBUG_MARKER_INSERT_EXT_MWN = 3819984443, + VK_FUNCTION_CMD_EXECUTE_GENERATED_COMMANDS_NV_MWN = 611070094, + VK_FUNCTION_CMD_PREPROCESS_GENERATED_COMMANDS_NV_MWN = 3197291730, + VK_FUNCTION_CMD_BIND_PIPELINE_SHADER_GROUP_NV_MWN = 2281040777, + VK_FUNCTION_GET_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_NV_MWN = 790028674, + VK_FUNCTION_CREATE_INDIRECT_COMMANDS_LAYOUT_NV_MWN = 920399246, + VK_FUNCTION_DESTROY_INDIRECT_COMMANDS_LAYOUT_NV_MWN = 3680797167, + VK_FUNCTION_CMD_PUSH_DESCRIPTOR_SET_KHR_MWN = 2383465383, + VK_FUNCTION_TRIM_COMMAND_POOL_MWN = 2372188109, + VK_FUNCTION_GET_MEMORY_FD_KHR_MWN = 2544923704, + VK_FUNCTION_GET_MEMORY_FD_PROPERTIES_KHR_MWN = 1460697854, + VK_FUNCTION_GET_MEMORY_REMOTE_ADDRESS_NV_MWN = 2331663334, + VK_FUNCTION_GET_SEMAPHORE_FD_KHR_MWN = 1643224081, + VK_FUNCTION_IMPORT_SEMAPHORE_FD_KHR_MWN = 3274366938, + VK_FUNCTION_GET_FENCE_FD_KHR_MWN = 248481722, + VK_FUNCTION_IMPORT_FENCE_FD_KHR_MWN = 1855486518, + VK_FUNCTION_DISPLAY_POWER_CONTROL_EXT_MWN = 1971130664, + VK_FUNCTION_REGISTER_DEVICE_EVENT_EXT_MWN = 1602726900, + VK_FUNCTION_REGISTER_DISPLAY_EVENT_EXT_MWN = 499717153, + VK_FUNCTION_GET_SWAPCHAIN_COUNTER_EXT_MWN = 3537170476, + VK_FUNCTION_GET_DEVICE_GROUP_PEER_MEMORY_FEATURES_MWN = 4099343621, + VK_FUNCTION_BIND_BUFFER_MEMORY2_MWN = 2433133068, + VK_FUNCTION_BIND_IMAGE_MEMORY2_MWN = 3288712634, + VK_FUNCTION_CMD_SET_DEVICE_MASK_MWN = 3569513564, + VK_FUNCTION_GET_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR_MWN = 391519764, + VK_FUNCTION_GET_DEVICE_GROUP_SURFACE_PRESENT_MODES_KHR_MWN = 1150912239, + VK_FUNCTION_ACQUIRE_NEXT_IMAGE2_KHR_MWN = 3876342299, + VK_FUNCTION_CMD_DISPATCH_BASE_MWN = 3501797912, + VK_FUNCTION_CREATE_DESCRIPTOR_UPDATE_TEMPLATE_MWN = 1338185187, + VK_FUNCTION_DESTROY_DESCRIPTOR_UPDATE_TEMPLATE_MWN = 2726017410, + VK_FUNCTION_UPDATE_DESCRIPTOR_SET_WITH_TEMPLATE_MWN = 872670538, + VK_FUNCTION_CMD_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_KHR_MWN = 2700669303, + VK_FUNCTION_SET_HDR_METADATA_EXT_MWN = 1205342361, + VK_FUNCTION_GET_SWAPCHAIN_STATUS_KHR_MWN = 1543585735, + VK_FUNCTION_GET_REFRESH_CYCLE_DURATION_GOOGLE_MWN = 3747314023, + VK_FUNCTION_GET_PAST_PRESENTATION_TIMING_GOOGLE_MWN = 1303203707, + VK_FUNCTION_CMD_SET_VIEWPORT_WSCALING_NV_MWN = 799373220, + VK_FUNCTION_CMD_SET_DISCARD_RECTANGLE_EXT_MWN = 2062852222, + VK_FUNCTION_CMD_SET_SAMPLE_LOCATIONS_EXT_MWN = 3093069744, + VK_FUNCTION_GET_BUFFER_MEMORY_REQUIREMENTS2_MWN = 2557063632, + VK_FUNCTION_GET_IMAGE_MEMORY_REQUIREMENTS2_MWN = 3508342199, + VK_FUNCTION_GET_IMAGE_SPARSE_MEMORY_REQUIREMENTS2_MWN = 1631224108, + VK_FUNCTION_GET_DEVICE_BUFFER_MEMORY_REQUIREMENTS_MWN = 2579930640, + VK_FUNCTION_GET_DEVICE_IMAGE_MEMORY_REQUIREMENTS_MWN = 2523790671, + VK_FUNCTION_GET_DEVICE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_MWN = 3262017727, + VK_FUNCTION_CREATE_SAMPLER_YCBCR_CONVERSION_MWN = 3472013538, + VK_FUNCTION_DESTROY_SAMPLER_YCBCR_CONVERSION_MWN = 3786619106, + VK_FUNCTION_GET_DEVICE_QUEUE2_MWN = 2899888647, + VK_FUNCTION_CREATE_VALIDATION_CACHE_EXT_MWN = 613407559, + VK_FUNCTION_DESTROY_VALIDATION_CACHE_EXT_MWN = 2004596965, + VK_FUNCTION_GET_VALIDATION_CACHE_DATA_EXT_MWN = 3821960649, + VK_FUNCTION_MERGE_VALIDATION_CACHES_EXT_MWN = 510162960, + VK_FUNCTION_GET_DESCRIPTOR_SET_LAYOUT_SUPPORT_MWN = 298165328, + VK_FUNCTION_GET_SHADER_INFO_AMD_MWN = 3476093854, + VK_FUNCTION_SET_LOCAL_DIMMING_AMD_MWN = 1419022688, + VK_FUNCTION_GET_CALIBRATED_TIMESTAMPS_EXT_MWN = 14945455, + VK_FUNCTION_SET_DEBUG_UTILS_OBJECT_NAME_EXT_MWN = 3052068665, + VK_FUNCTION_SET_DEBUG_UTILS_OBJECT_TAG_EXT_MWN = 907927425, + VK_FUNCTION_QUEUE_BEGIN_DEBUG_UTILS_LABEL_EXT_MWN = 4215750604, + VK_FUNCTION_QUEUE_END_DEBUG_UTILS_LABEL_EXT_MWN = 1467516025, + VK_FUNCTION_QUEUE_INSERT_DEBUG_UTILS_LABEL_EXT_MWN = 3084381869, + VK_FUNCTION_CMD_BEGIN_DEBUG_UTILS_LABEL_EXT_MWN = 2267729576, + VK_FUNCTION_CMD_END_DEBUG_UTILS_LABEL_EXT_MWN = 1111649858, + VK_FUNCTION_CMD_INSERT_DEBUG_UTILS_LABEL_EXT_MWN = 4252247581, + VK_FUNCTION_GET_MEMORY_HOST_POINTER_PROPERTIES_EXT_MWN = 1107819012, + VK_FUNCTION_CMD_WRITE_BUFFER_MARKER_AMD_MWN = 199508757, + VK_FUNCTION_CREATE_RENDER_PASS2_MWN = 2957544060, + VK_FUNCTION_CMD_BEGIN_RENDER_PASS2_MWN = 1755368593, + VK_FUNCTION_CMD_NEXT_SUBPASS2_MWN = 937492878, + VK_FUNCTION_CMD_END_RENDER_PASS2_MWN = 2689299296, + VK_FUNCTION_GET_SEMAPHORE_COUNTER_VALUE_MWN = 1175841333, + VK_FUNCTION_WAIT_SEMAPHORES_MWN = 4077631746, + VK_FUNCTION_SIGNAL_SEMAPHORE_MWN = 2734621155, + VK_FUNCTION_CMD_DRAW_INDIRECT_COUNT_MWN = 4232869586, + VK_FUNCTION_CMD_DRAW_INDEXED_INDIRECT_COUNT_MWN = 2748642117, + VK_FUNCTION_CMD_SET_CHECKPOINT_NV_MWN = 602460120, + VK_FUNCTION_GET_QUEUE_CHECKPOINT_DATA_NV_MWN = 2389627936, + VK_FUNCTION_CMD_BIND_TRANSFORM_FEEDBACK_BUFFERS_EXT_MWN = 4147325197, + VK_FUNCTION_CMD_BEGIN_TRANSFORM_FEEDBACK_EXT_MWN = 54612038, + VK_FUNCTION_CMD_END_TRANSFORM_FEEDBACK_EXT_MWN = 1896230304, + VK_FUNCTION_CMD_BEGIN_QUERY_INDEXED_EXT_MWN = 2150096661, + VK_FUNCTION_CMD_END_QUERY_INDEXED_EXT_MWN = 1489663839, + VK_FUNCTION_CMD_DRAW_INDIRECT_BYTE_COUNT_EXT_MWN = 2667217402, + VK_FUNCTION_CMD_SET_EXCLUSIVE_SCISSOR_NV_MWN = 417353787, + VK_FUNCTION_CMD_BIND_SHADING_RATE_IMAGE_NV_MWN = 949605291, + VK_FUNCTION_CMD_SET_VIEWPORT_SHADING_RATE_PALETTE_NV_MWN = 3390771085, + VK_FUNCTION_CMD_SET_COARSE_SAMPLE_ORDER_NV_MWN = 2141814502, + VK_FUNCTION_CMD_DRAW_MESH_TASKS_NV_MWN = 2370740991, + VK_FUNCTION_CMD_DRAW_MESH_TASKS_INDIRECT_NV_MWN = 1398964463, + VK_FUNCTION_CMD_DRAW_MESH_TASKS_INDIRECT_COUNT_NV_MWN = 1280937501, + VK_FUNCTION_COMPILE_DEFERRED_NV_MWN = 1762658299, + VK_FUNCTION_CREATE_ACCELERATION_STRUCTURE_NV_MWN = 3574510498, + VK_FUNCTION_CMD_BIND_INVOCATION_MASK_HUAWEI_MWN = 2556353319, + VK_FUNCTION_DESTROY_ACCELERATION_STRUCTURE_KHR_MWN = 1347961463, + VK_FUNCTION_DESTROY_ACCELERATION_STRUCTURE_NV_MWN = 3575771682, + VK_FUNCTION_GET_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_NV_MWN = 2261493858, + VK_FUNCTION_BIND_ACCELERATION_STRUCTURE_MEMORY_NV_MWN = 2682401199, + VK_FUNCTION_CMD_COPY_ACCELERATION_STRUCTURE_NV_MWN = 1769933246, + VK_FUNCTION_CMD_COPY_ACCELERATION_STRUCTURE_KHR_MWN = 2841494499, + VK_FUNCTION_COPY_ACCELERATION_STRUCTURE_KHR_MWN = 746927364, + VK_FUNCTION_CMD_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_KHR_MWN = 1690226191, + VK_FUNCTION_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_KHR_MWN = 1835945012, + VK_FUNCTION_CMD_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_KHR_MWN = 2252662692, + VK_FUNCTION_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_KHR_MWN = 2408867231, + VK_FUNCTION_CMD_WRITE_ACCELERATION_STRUCTURES_PROPERTIES_KHR_MWN = 3083780648, + VK_FUNCTION_CMD_WRITE_ACCELERATION_STRUCTURES_PROPERTIES_NV_MWN = 4220299820, + VK_FUNCTION_CMD_BUILD_ACCELERATION_STRUCTURE_NV_MWN = 3617635760, + VK_FUNCTION_WRITE_ACCELERATION_STRUCTURES_PROPERTIES_KHR_MWN = 2326859741, + VK_FUNCTION_CMD_TRACE_RAYS_KHR_MWN = 642627754, + VK_FUNCTION_CMD_TRACE_RAYS_NV_MWN = 479903586, + VK_FUNCTION_GET_RAY_TRACING_SHADER_GROUP_HANDLES_KHR_MWN = 2234315647, + VK_FUNCTION_GET_RAY_TRACING_CAPTURE_REPLAY_SHADER_GROUP_HANDLES_KHR_MWN = 32704974, + VK_FUNCTION_GET_ACCELERATION_STRUCTURE_HANDLE_NV_MWN = 495425266, + VK_FUNCTION_CREATE_RAY_TRACING_PIPELINES_NV_MWN = 383229838, + VK_FUNCTION_CREATE_RAY_TRACING_PIPELINES_KHR_MWN = 2415614937, + VK_FUNCTION_CMD_TRACE_RAYS_INDIRECT_KHR_MWN = 3772374059, + VK_FUNCTION_CMD_TRACE_RAYS_INDIRECT2_KHR_MWN = 1600607325, + VK_FUNCTION_GET_DEVICE_ACCELERATION_STRUCTURE_COMPATIBILITY_KHR_MWN = 3768745418, + VK_FUNCTION_GET_RAY_TRACING_SHADER_GROUP_STACK_SIZE_KHR_MWN = 4187714816, + VK_FUNCTION_CMD_SET_RAY_TRACING_PIPELINE_STACK_SIZE_KHR_MWN = 2224084205, + VK_FUNCTION_GET_IMAGE_VIEW_HANDLE_NVX_MWN = 2370104344, + VK_FUNCTION_GET_IMAGE_VIEW_ADDRESS_NVX_MWN = 3242720664, + VK_FUNCTION_ACQUIRE_PROFILING_LOCK_KHR_MWN = 3696002283, + VK_FUNCTION_RELEASE_PROFILING_LOCK_KHR_MWN = 1009450468, + VK_FUNCTION_GET_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT_MWN = 1111583318, + VK_FUNCTION_GET_BUFFER_OPAQUE_CAPTURE_ADDRESS_MWN = 3444523422, + VK_FUNCTION_GET_BUFFER_DEVICE_ADDRESS_MWN = 2165413050, + VK_FUNCTION_INITIALIZE_PERFORMANCE_API_INTEL_MWN = 3213306329, + VK_FUNCTION_UNINITIALIZE_PERFORMANCE_API_INTEL_MWN = 272945663, + VK_FUNCTION_CMD_SET_PERFORMANCE_MARKER_INTEL_MWN = 2664792030, + VK_FUNCTION_CMD_SET_PERFORMANCE_STREAM_MARKER_INTEL_MWN = 58256893, + VK_FUNCTION_CMD_SET_PERFORMANCE_OVERRIDE_INTEL_MWN = 1596194089, + VK_FUNCTION_ACQUIRE_PERFORMANCE_CONFIGURATION_INTEL_MWN = 881818662, + VK_FUNCTION_RELEASE_PERFORMANCE_CONFIGURATION_INTEL_MWN = 631194492, + VK_FUNCTION_QUEUE_SET_PERFORMANCE_CONFIGURATION_INTEL_MWN = 2412941192, + VK_FUNCTION_GET_PERFORMANCE_PARAMETER_INTEL_MWN = 2720461460, + VK_FUNCTION_GET_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_MWN = 1044173864, + VK_FUNCTION_GET_PIPELINE_EXECUTABLE_PROPERTIES_KHR_MWN = 2745491988, + VK_FUNCTION_GET_PIPELINE_EXECUTABLE_STATISTICS_KHR_MWN = 252749420, + VK_FUNCTION_GET_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATIONS_KHR_MWN = 3713473300, + VK_FUNCTION_CMD_SET_LINE_STIPPLE_EXT_MWN = 492579146, + VK_FUNCTION_CREATE_ACCELERATION_STRUCTURE_KHR_MWN = 3185634838, + VK_FUNCTION_CMD_BUILD_ACCELERATION_STRUCTURES_KHR_MWN = 3149283676, + VK_FUNCTION_CMD_BUILD_ACCELERATION_STRUCTURES_INDIRECT_KHR_MWN = 2130228375, + VK_FUNCTION_BUILD_ACCELERATION_STRUCTURES_KHR_MWN = 4267177606, + VK_FUNCTION_GET_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_KHR_MWN = 49140511, + VK_FUNCTION_CREATE_DEFERRED_OPERATION_KHR_MWN = 2777485241, + VK_FUNCTION_DESTROY_DEFERRED_OPERATION_KHR_MWN = 3976704708, + VK_FUNCTION_GET_DEFERRED_OPERATION_MAX_CONCURRENCY_KHR_MWN = 4070044399, + VK_FUNCTION_GET_DEFERRED_OPERATION_RESULT_KHR_MWN = 966385575, + VK_FUNCTION_DEFERRED_OPERATION_JOIN_KHR_MWN = 293820119, + VK_FUNCTION_CMD_SET_CULL_MODE_MWN = 4093834086, + VK_FUNCTION_CMD_SET_FRONT_FACE_MWN = 1444353066, + VK_FUNCTION_CMD_SET_PRIMITIVE_TOPOLOGY_MWN = 617273307, + VK_FUNCTION_CMD_SET_VIEWPORT_WITH_COUNT_MWN = 895297042, + VK_FUNCTION_CMD_SET_SCISSOR_WITH_COUNT_MWN = 659999523, + VK_FUNCTION_CMD_BIND_VERTEX_BUFFERS2_MWN = 256716791, + VK_FUNCTION_CMD_SET_DEPTH_TEST_ENABLE_MWN = 3679209209, + VK_FUNCTION_CMD_SET_DEPTH_WRITE_ENABLE_MWN = 2809211598, + VK_FUNCTION_CMD_SET_DEPTH_COMPARE_OP_MWN = 274204163, + VK_FUNCTION_CMD_SET_DEPTH_BOUNDS_TEST_ENABLE_MWN = 2371893853, + VK_FUNCTION_CMD_SET_STENCIL_TEST_ENABLE_MWN = 2109230784, + VK_FUNCTION_CMD_SET_STENCIL_OP_MWN = 2767891761, + VK_FUNCTION_CMD_SET_PATCH_CONTROL_POINTS_EXT_MWN = 2856586336, + VK_FUNCTION_CMD_SET_RASTERIZER_DISCARD_ENABLE_MWN = 1751478540, + VK_FUNCTION_CMD_SET_DEPTH_BIAS_ENABLE_MWN = 3975236762, + VK_FUNCTION_CMD_SET_LOGIC_OP_EXT_MWN = 2487789106, + VK_FUNCTION_CMD_SET_PRIMITIVE_RESTART_ENABLE_MWN = 3406730423, + VK_FUNCTION_CREATE_PRIVATE_DATA_SLOT_MWN = 4263495810, + VK_FUNCTION_DESTROY_PRIVATE_DATA_SLOT_MWN = 285887147, + VK_FUNCTION_SET_PRIVATE_DATA_MWN = 1134828454, + VK_FUNCTION_GET_PRIVATE_DATA_MWN = 1018865873, + VK_FUNCTION_CMD_COPY_BUFFER2_MWN = 2494150042, + VK_FUNCTION_CMD_COPY_IMAGE2_MWN = 310006019, + VK_FUNCTION_CMD_BLIT_IMAGE2_MWN = 3323350328, + VK_FUNCTION_CMD_COPY_BUFFER_TO_IMAGE2_MWN = 4011196695, + VK_FUNCTION_CMD_COPY_IMAGE_TO_BUFFER2_MWN = 3819047898, + VK_FUNCTION_CMD_RESOLVE_IMAGE2_MWN = 2328936816, + VK_FUNCTION_CMD_SET_FRAGMENT_SHADING_RATE_KHR_MWN = 101088162, + VK_FUNCTION_CMD_SET_FRAGMENT_SHADING_RATE_ENUM_NV_MWN = 3850811256, + VK_FUNCTION_GET_ACCELERATION_STRUCTURE_BUILD_SIZES_KHR_MWN = 320509077, + VK_FUNCTION_CMD_SET_VERTEX_INPUT_EXT_MWN = 2635238551, + VK_FUNCTION_CMD_SET_COLOR_WRITE_ENABLE_EXT_MWN = 21998197, + VK_FUNCTION_CMD_SET_EVENT2_MWN = 22829937, + VK_FUNCTION_CMD_RESET_EVENT2_MWN = 435798327, + VK_FUNCTION_CMD_WAIT_EVENTS2_MWN = 3404805506, + VK_FUNCTION_CMD_PIPELINE_BARRIER2_MWN = 4236350456, + VK_FUNCTION_QUEUE_SUBMIT2_MWN = 2962788892, + VK_FUNCTION_CMD_WRITE_TIMESTAMP2_MWN = 3214480911, + VK_FUNCTION_CMD_WRITE_BUFFER_MARKER2_AMD_MWN = 1865885683, + VK_FUNCTION_GET_QUEUE_CHECKPOINT_DATA2_NV_MWN = 3021626429, + VK_FUNCTION_CREATE_CU_MODULE_NVX_MWN = 661546257, + VK_FUNCTION_CREATE_CU_FUNCTION_NVX_MWN = 1756930047, + VK_FUNCTION_DESTROY_CU_MODULE_NVX_MWN = 2892740100, + VK_FUNCTION_DESTROY_CU_FUNCTION_NVX_MWN = 1087861120, + VK_FUNCTION_CMD_CU_LAUNCH_KERNEL_NVX_MWN = 547196128, + VK_FUNCTION_SET_DEVICE_MEMORY_PRIORITY_EXT_MWN = 1030260359, + VK_FUNCTION_WAIT_FOR_PRESENT_KHR_MWN = 2271445703, + VK_FUNCTION_CMD_BEGIN_RENDERING_MWN = 2884379966, + VK_FUNCTION_CMD_END_RENDERING_MWN = 1182385690, + VK_FUNCTION_GET_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE_MWN = 66268984, + VK_FUNCTION_GET_DESCRIPTOR_SET_HOST_MAPPING_VALVE_MWN = 4051636062, + VK_FUNCTION_GET_IMAGE_SUBRESOURCE_LAYOUT2_EXT_MWN = 3241952166, + VK_FUNCTION_GET_PIPELINE_PROPERTIES_EXT_MWN = 2463196004, +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + + VK_FUNCTION_GET_SWAPCHAIN_GRALLOC_USAGE_ANDROID_MWN = 770334981, + VK_FUNCTION_GET_SWAPCHAIN_GRALLOC_USAGE2_ANDROID_MWN = 1510497929, + VK_FUNCTION_ACQUIRE_IMAGE_ANDROID_MWN = 3886703442, + VK_FUNCTION_QUEUE_SIGNAL_RELEASE_IMAGE_ANDROID_MWN = 1928178446, + VK_FUNCTION_GET_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID_MWN = 3351560814, + VK_FUNCTION_GET_MEMORY_ANDROID_HARDWARE_BUFFER_ANDROID_MWN = 4117610260, +#endif // defined(VK_USE_PLATFORM_ANDROID_KHR) + +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) + +#endif // defined(VK_USE_PLATFORM_DIRECTFB_EXT) + +#if defined(VK_USE_PLATFORM_FUCHSIA) + + VK_FUNCTION_GET_MEMORY_ZIRCON_HANDLE_FUCHSIA_MWN = 229516057, + VK_FUNCTION_GET_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA_MWN = 2759011490, + VK_FUNCTION_GET_SEMAPHORE_ZIRCON_HANDLE_FUCHSIA_MWN = 1354161685, + VK_FUNCTION_IMPORT_SEMAPHORE_ZIRCON_HANDLE_FUCHSIA_MWN = 1497141989, + VK_FUNCTION_CREATE_BUFFER_COLLECTION_FUCHSIA_MWN = 1939361836, + VK_FUNCTION_SET_BUFFER_COLLECTION_BUFFER_CONSTRAINTS_FUCHSIA_MWN = 2866373639, + VK_FUNCTION_SET_BUFFER_COLLECTION_IMAGE_CONSTRAINTS_FUCHSIA_MWN = 3146098621, + VK_FUNCTION_DESTROY_BUFFER_COLLECTION_FUCHSIA_MWN = 1941377452, + VK_FUNCTION_GET_BUFFER_COLLECTION_PROPERTIES_FUCHSIA_MWN = 3501860002, +#endif // defined(VK_USE_PLATFORM_FUCHSIA) + +#if defined(VK_USE_PLATFORM_GGP) + +#endif // defined(VK_USE_PLATFORM_GGP) + +#if defined(VK_USE_PLATFORM_IOS_MVK) + +#endif // defined(VK_USE_PLATFORM_IOS_MVK) + +#if defined(VK_USE_PLATFORM_MACOS_MVK) + +#endif // defined(VK_USE_PLATFORM_MACOS_MVK) + +#if defined(VK_USE_PLATFORM_METAL_EXT) + + VK_FUNCTION_EXPORT_METAL_OBJECTS_EXT_MWN = 424680822, +#endif // defined(VK_USE_PLATFORM_METAL_EXT) + +#if defined(VK_ENABLE_BETA_EXTENSIONS) + + VK_FUNCTION_CREATE_VIDEO_SESSION_KHR_MWN = 2122860554, + VK_FUNCTION_DESTROY_VIDEO_SESSION_KHR_MWN = 2443037219, + VK_FUNCTION_CREATE_VIDEO_SESSION_PARAMETERS_KHR_MWN = 2368732644, + VK_FUNCTION_UPDATE_VIDEO_SESSION_PARAMETERS_KHR_MWN = 1590107430, + VK_FUNCTION_DESTROY_VIDEO_SESSION_PARAMETERS_KHR_MWN = 3078034566, + VK_FUNCTION_GET_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR_MWN = 1734238379, + VK_FUNCTION_BIND_VIDEO_SESSION_MEMORY_KHR_MWN = 3166741804, + VK_FUNCTION_CMD_DECODE_VIDEO_KHR_MWN = 668832445, + VK_FUNCTION_CMD_BEGIN_VIDEO_CODING_KHR_MWN = 1040122322, + VK_FUNCTION_CMD_CONTROL_VIDEO_CODING_KHR_MWN = 4253541250, + VK_FUNCTION_CMD_END_VIDEO_CODING_KHR_MWN = 3715928442, + VK_FUNCTION_CMD_ENCODE_VIDEO_KHR_MWN = 1562102888, +#endif // defined(VK_ENABLE_BETA_EXTENSIONS) + +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + +#endif // defined(VK_USE_PLATFORM_SCREEN_QNX) + +#if defined(VK_USE_PLATFORM_VI_NN) + +#endif // defined(VK_USE_PLATFORM_VI_NN) + +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + +#endif // defined(VK_USE_PLATFORM_WAYLAND_KHR) + +#if defined(VK_USE_PLATFORM_WIN32_KHR) + + VK_FUNCTION_GET_MEMORY_WIN32_HANDLE_NV_MWN = 1511382935, + VK_FUNCTION_GET_MEMORY_WIN32_HANDLE_KHR_MWN = 3957076313, + VK_FUNCTION_GET_MEMORY_WIN32_HANDLE_PROPERTIES_KHR_MWN = 1371298899, + VK_FUNCTION_GET_SEMAPHORE_WIN32_HANDLE_KHR_MWN = 3020734396, + VK_FUNCTION_IMPORT_SEMAPHORE_WIN32_HANDLE_KHR_MWN = 3566993533, + VK_FUNCTION_GET_FENCE_WIN32_HANDLE_KHR_MWN = 4073909616, + VK_FUNCTION_IMPORT_FENCE_WIN32_HANDLE_KHR_MWN = 4166764499, + VK_FUNCTION_ACQUIRE_FULL_SCREEN_EXCLUSIVE_MODE_EXT_MWN = 1030778345, + VK_FUNCTION_RELEASE_FULL_SCREEN_EXCLUSIVE_MODE_EXT_MWN = 2237615297, +#endif // defined(VK_USE_PLATFORM_WIN32_KHR) + +#if defined(VK_USE_PLATFORM_XCB_KHR) + +#endif // defined(VK_USE_PLATFORM_XCB_KHR) + +#if defined(VK_USE_PLATFORM_XLIB_KHR) + +#endif // defined(VK_USE_PLATFORM_XLIB_KHR) + +#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) +#endif // defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) + +} VkFunctionMWN; + +#if defined(__cplusplus) +} // extern "C" +#endif + +#endif // VK_CAPTURE_FUNCTION_IDS_H_INCLUDED diff --git a/source/common.hpp b/source/common.hpp new file mode 100644 index 0000000..7020189 --- /dev/null +++ b/source/common.hpp @@ -0,0 +1,39 @@ + +#pragma once + +#if !defined(VK_CAPTURE_COMMON_HPP_INCLUDED) +#define VK_CAPTURE_COMMON_HPP_INCLUDED 1 + +#include +#include "vk_capture.h" + +namespace vk_capture +{ + +// +// public defines +// + +// +// public constants +// + +// +// public types +// + +// +// public functions +// + +VkVariantMWN* allocVariant(std::size_t num); +void* allocData(std::size_t bytes, std::size_t alignment = 1); + +template +inline T* allocType(std::size_t count = 1) { + return static_cast(allocData(sizeof(T) * count, alignof(T))); +} + +} // namespace vk_capture + +#endif // !defined(VK_CAPTURE_COMMON_HPP_INCLUDED) diff --git a/source/data_pool.cpp b/source/data_pool.cpp new file mode 100644 index 0000000..bc4a20a --- /dev/null +++ b/source/data_pool.cpp @@ -0,0 +1,57 @@ + +#include "data_pool.hpp" + +#include + +namespace vk_capture +{ + +// +// internal defines +// + +// +// internal constants +// + +// +// internal types +// + +// +// internal variables +// + +// +// internal functions +// + +// +// public functions +// + +void* DataPool::allocate(std::size_t bytes, std::size_t alignment) +{ + assert(bytes > 0 && bytes <= PAGE_SIZE); + assert(alignment > 0 && alignment <= alignof(std::max_align_t)); + + if (offset % alignment != 0) { + offset += alignment - (offset % alignment); + } + + const std::size_t remainingOnPage = PAGE_SIZE - (offset % PAGE_SIZE); + if (remainingOnPage == PAGE_SIZE || remainingOnPage < bytes) + { + // next page + pages.push_back(std::make_unique()); + offset = PAGE_SIZE * (pages.size() - 1); + } + const std::size_t page = offset / PAGE_SIZE; + const std::size_t localOffset = offset % PAGE_SIZE; + std::uint8_t* result = &(*pages[page])[localOffset]; + offset += bytes; + assert(reinterpret_cast(result) % alignment == 0); + return result; +} + +} // namespace vk_capture diff --git a/source/data_pool.hpp b/source/data_pool.hpp new file mode 100644 index 0000000..c90005b --- /dev/null +++ b/source/data_pool.hpp @@ -0,0 +1,50 @@ + +#pragma once + +#if !defined(VK_CAPTURE_DATA_POOL_HPP_INCLUDED) +#define VK_CAPTURE_DATA_POOL_HPP_INCLUDED 1 + +#include +#include +#include +#include +#include + +namespace vk_capture +{ + +// +// public defines +// + +// +// public constants +// + +// +// public types +// + +struct DataPool +{ + static constexpr std::size_t PAGE_SIZE = 4096 * 1024; + static_assert(PAGE_SIZE % alignof(std::max_align_t) == 0); + + struct alignas(std::max_align_t) Page : std::array {}; + + using page_ptr_t = std::unique_ptr; + + std::vector pages; + std::size_t offset = 0; + + void* allocate(std::size_t bytes, std::size_t alignment = 1); + inline void reset() { offset = 0; } +}; + +// +// public functions +// + +} // namespace vk_capture + +#endif // !defined(VK_CAPTURE_DATA_POOL_HPP_INCLUDED) diff --git a/source/dispatch_table.cpp b/source/dispatch_table.cpp new file mode 100644 index 0000000..754667f --- /dev/null +++ b/source/dispatch_table.cpp @@ -0,0 +1,39 @@ + +#include "dispatch_table.hpp" + +namespace vk_capture +{ + +// +// internal defines +// + +// +// internal constants +// + +// +// internal types +// + +// +// internal variables +// + +// +// internal functions +// + +// +// public variables +// + +// TODO: this won't work for multi-device setups, we'd need a hashmap of sort then +VkLayerInstanceDispatchTable g_instanceDispatchTable; +VkLayerDispatchTable g_dispatchTable; + +// +// public functions +// + +} // namespace sekiei diff --git a/source/dispatch_table.hpp b/source/dispatch_table.hpp new file mode 100644 index 0000000..a2c5826 --- /dev/null +++ b/source/dispatch_table.hpp @@ -0,0 +1,38 @@ + +#pragma once + +#if !defined(VK_CAPTURE_DISPATCH_TABLE_HPP_INCLUDED) +#define VK_CAPTURE_DISPATCH_TABLE_HPP_INCLUDED 1 + +#include + +namespace vk_capture +{ + +// +// public defines +// + +// +// public constants +// + +// +// public types +// + +// +// public variables +// + +// TODO: this won't work for multi-device setups, we'd need a hashmap of sort then +extern VkLayerInstanceDispatchTable g_instanceDispatchTable; +extern VkLayerDispatchTable g_dispatchTable; + +// +// public functions +// + +} // namespace vk_capture + +#endif // !defined(VK_CAPTURE_DISPATCH_TABLE_HPP_INCLUDED) diff --git a/source/functions.cpp b/source/functions.cpp new file mode 100644 index 0000000..5821b9f --- /dev/null +++ b/source/functions.cpp @@ -0,0 +1,3518 @@ + +// This file has been automatically generated. Do NOT edit edit manually, all your changes will be lost when it is regenerated. + +#include +#include "dispatch_table.hpp" +#include "functions.hpp" +#include "record_list.hpp" +#include "vk_function_ids.h" +namespace vk_capture +{ +void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) +{ + g_dispatchTable.GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); + recordVoidFunction(VK_FUNCTION_GET_DEVICE_QUEUE_MWN, device, queueFamilyIndex, queueIndex, pQueue); +} +VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) +{ + auto result = g_dispatchTable.QueueSubmit(queue, submitCount, pSubmits, fence); + recordFunction(VK_FUNCTION_QUEUE_SUBMIT_MWN, result, queue, submitCount, pSubmits, fence); + return result; +} +VkResult vkQueueWaitIdle(VkQueue queue) +{ + auto result = g_dispatchTable.QueueWaitIdle(queue); + recordFunction(VK_FUNCTION_QUEUE_WAIT_IDLE_MWN, result, queue); + return result; +} +VkResult vkDeviceWaitIdle(VkDevice device) +{ + auto result = g_dispatchTable.DeviceWaitIdle(device); + recordFunction(VK_FUNCTION_DEVICE_WAIT_IDLE_MWN, result, device); + return result; +} +VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) +{ + auto result = g_dispatchTable.AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); + recordFunction(VK_FUNCTION_ALLOCATE_MEMORY_MWN, result, device, pAllocateInfo, pAllocator, pMemory); + return result; +} +void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.FreeMemory(device, memory, pAllocator); + recordVoidFunction(VK_FUNCTION_FREE_MEMORY_MWN, device, memory, pAllocator); +} +VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) +{ + auto result = g_dispatchTable.MapMemory(device, memory, offset, size, flags, ppData); + recordFunction(VK_FUNCTION_MAP_MEMORY_MWN, result, device, memory, offset, size, flags, ppData); + return result; +} +void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) +{ + g_dispatchTable.UnmapMemory(device, memory); + recordVoidFunction(VK_FUNCTION_UNMAP_MEMORY_MWN, device, memory); +} +VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + auto result = g_dispatchTable.FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); + recordFunction(VK_FUNCTION_FLUSH_MAPPED_MEMORY_RANGES_MWN, result, device, memoryRangeCount, pMemoryRanges); + return result; +} +VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) +{ + auto result = g_dispatchTable.InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); + recordFunction(VK_FUNCTION_INVALIDATE_MAPPED_MEMORY_RANGES_MWN, result, device, memoryRangeCount, pMemoryRanges); + return result; +} +void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) +{ + g_dispatchTable.GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); + recordVoidFunction(VK_FUNCTION_GET_DEVICE_MEMORY_COMMITMENT_MWN, device, memory, pCommittedMemoryInBytes); +} +void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) +{ + g_dispatchTable.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); + recordVoidFunction(VK_FUNCTION_GET_BUFFER_MEMORY_REQUIREMENTS_MWN, device, buffer, pMemoryRequirements); +} +VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + auto result = g_dispatchTable.BindBufferMemory(device, buffer, memory, memoryOffset); + recordFunction(VK_FUNCTION_BIND_BUFFER_MEMORY_MWN, result, device, buffer, memory, memoryOffset); + return result; +} +void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) +{ + g_dispatchTable.GetImageMemoryRequirements(device, image, pMemoryRequirements); + recordVoidFunction(VK_FUNCTION_GET_IMAGE_MEMORY_REQUIREMENTS_MWN, device, image, pMemoryRequirements); +} +VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) +{ + auto result = g_dispatchTable.BindImageMemory(device, image, memory, memoryOffset); + recordFunction(VK_FUNCTION_BIND_IMAGE_MEMORY_MWN, result, device, image, memory, memoryOffset); + return result; +} +void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) +{ + g_dispatchTable.GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + recordVoidFunction(VK_FUNCTION_GET_IMAGE_SPARSE_MEMORY_REQUIREMENTS_MWN, device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} +VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) +{ + auto result = g_dispatchTable.QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); + recordFunction(VK_FUNCTION_QUEUE_BIND_SPARSE_MWN, result, queue, bindInfoCount, pBindInfo, fence); + return result; +} +VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + auto result = g_dispatchTable.CreateFence(device, pCreateInfo, pAllocator, pFence); + recordFunction(VK_FUNCTION_CREATE_FENCE_MWN, result, device, pCreateInfo, pAllocator, pFence); + return result; +} +void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyFence(device, fence, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_FENCE_MWN, device, fence, pAllocator); +} +VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) +{ + auto result = g_dispatchTable.ResetFences(device, fenceCount, pFences); + recordFunction(VK_FUNCTION_RESET_FENCES_MWN, result, device, fenceCount, pFences); + return result; +} +VkResult vkGetFenceStatus(VkDevice device, VkFence fence) +{ + auto result = g_dispatchTable.GetFenceStatus(device, fence); + recordFunction(VK_FUNCTION_GET_FENCE_STATUS_MWN, result, device, fence); + return result; +} +VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) +{ + auto result = g_dispatchTable.WaitForFences(device, fenceCount, pFences, waitAll, timeout); + recordFunction(VK_FUNCTION_WAIT_FOR_FENCES_MWN, result, device, fenceCount, pFences, waitAll, timeout); + return result; +} +VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) +{ + auto result = g_dispatchTable.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); + recordFunction(VK_FUNCTION_CREATE_SEMAPHORE_MWN, result, device, pCreateInfo, pAllocator, pSemaphore); + return result; +} +void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroySemaphore(device, semaphore, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_SEMAPHORE_MWN, device, semaphore, pAllocator); +} +VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) +{ + auto result = g_dispatchTable.CreateEvent(device, pCreateInfo, pAllocator, pEvent); + recordFunction(VK_FUNCTION_CREATE_EVENT_MWN, result, device, pCreateInfo, pAllocator, pEvent); + return result; +} +void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyEvent(device, event, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_EVENT_MWN, device, event, pAllocator); +} +VkResult vkGetEventStatus(VkDevice device, VkEvent event) +{ + auto result = g_dispatchTable.GetEventStatus(device, event); + recordFunction(VK_FUNCTION_GET_EVENT_STATUS_MWN, result, device, event); + return result; +} +VkResult vkSetEvent(VkDevice device, VkEvent event) +{ + auto result = g_dispatchTable.SetEvent(device, event); + recordFunction(VK_FUNCTION_SET_EVENT_MWN, result, device, event); + return result; +} +VkResult vkResetEvent(VkDevice device, VkEvent event) +{ + auto result = g_dispatchTable.ResetEvent(device, event); + recordFunction(VK_FUNCTION_RESET_EVENT_MWN, result, device, event); + return result; +} +VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) +{ + auto result = g_dispatchTable.CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); + recordFunction(VK_FUNCTION_CREATE_QUERY_POOL_MWN, result, device, pCreateInfo, pAllocator, pQueryPool); + return result; +} +void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyQueryPool(device, queryPool, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_QUERY_POOL_MWN, device, queryPool, pAllocator); +} +VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) +{ + auto result = g_dispatchTable.GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); + recordFunction(VK_FUNCTION_GET_QUERY_POOL_RESULTS_MWN, result, device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); + return result; +} +void vkResetQueryPool(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + g_dispatchTable.ResetQueryPool(device, queryPool, firstQuery, queryCount); + recordVoidFunction(VK_FUNCTION_RESET_QUERY_POOL_MWN, device, queryPool, firstQuery, queryCount); +} +VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) +{ + auto result = g_dispatchTable.CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); + recordFunction(VK_FUNCTION_CREATE_BUFFER_MWN, result, device, pCreateInfo, pAllocator, pBuffer); + return result; +} +void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyBuffer(device, buffer, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_BUFFER_MWN, device, buffer, pAllocator); +} +VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) +{ + auto result = g_dispatchTable.CreateBufferView(device, pCreateInfo, pAllocator, pView); + recordFunction(VK_FUNCTION_CREATE_BUFFER_VIEW_MWN, result, device, pCreateInfo, pAllocator, pView); + return result; +} +void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyBufferView(device, bufferView, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_BUFFER_VIEW_MWN, device, bufferView, pAllocator); +} +VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) +{ + auto result = g_dispatchTable.CreateImage(device, pCreateInfo, pAllocator, pImage); + recordFunction(VK_FUNCTION_CREATE_IMAGE_MWN, result, device, pCreateInfo, pAllocator, pImage); + return result; +} +void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyImage(device, image, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_IMAGE_MWN, device, image, pAllocator); +} +void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) +{ + g_dispatchTable.GetImageSubresourceLayout(device, image, pSubresource, pLayout); + recordVoidFunction(VK_FUNCTION_GET_IMAGE_SUBRESOURCE_LAYOUT_MWN, device, image, pSubresource, pLayout); +} +VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) +{ + auto result = g_dispatchTable.CreateImageView(device, pCreateInfo, pAllocator, pView); + recordFunction(VK_FUNCTION_CREATE_IMAGE_VIEW_MWN, result, device, pCreateInfo, pAllocator, pView); + return result; +} +void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyImageView(device, imageView, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_IMAGE_VIEW_MWN, device, imageView, pAllocator); +} +VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) +{ + auto result = g_dispatchTable.CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); + recordFunction(VK_FUNCTION_CREATE_SHADER_MODULE_MWN, result, device, pCreateInfo, pAllocator, pShaderModule); + return result; +} +void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyShaderModule(device, shaderModule, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_SHADER_MODULE_MWN, device, shaderModule, pAllocator); +} +VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) +{ + auto result = g_dispatchTable.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); + recordFunction(VK_FUNCTION_CREATE_PIPELINE_CACHE_MWN, result, device, pCreateInfo, pAllocator, pPipelineCache); + return result; +} +void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyPipelineCache(device, pipelineCache, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_PIPELINE_CACHE_MWN, device, pipelineCache, pAllocator); +} +VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) +{ + auto result = g_dispatchTable.GetPipelineCacheData(device, pipelineCache, pDataSize, pData); + recordFunction(VK_FUNCTION_GET_PIPELINE_CACHE_DATA_MWN, result, device, pipelineCache, pDataSize, pData); + return result; +} +VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) +{ + auto result = g_dispatchTable.MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); + recordFunction(VK_FUNCTION_MERGE_PIPELINE_CACHES_MWN, result, device, dstCache, srcCacheCount, pSrcCaches); + return result; +} +VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + auto result = g_dispatchTable.CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + recordFunction(VK_FUNCTION_CREATE_GRAPHICS_PIPELINES_MWN, result, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + return result; +} +VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + auto result = g_dispatchTable.CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + recordFunction(VK_FUNCTION_CREATE_COMPUTE_PIPELINES_MWN, result, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + return result; +} +VkResult vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(VkDevice device, VkRenderPass renderpass, VkExtent2D* pMaxWorkgroupSize) +{ + auto result = g_dispatchTable.GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI(device, renderpass, pMaxWorkgroupSize); + recordFunction(VK_FUNCTION_GET_DEVICE_SUBPASS_SHADING_MAX_WORKGROUP_SIZE_HUAWEI_MWN, result, device, renderpass, pMaxWorkgroupSize); + return result; +} +void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyPipeline(device, pipeline, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_PIPELINE_MWN, device, pipeline, pAllocator); +} +VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) +{ + auto result = g_dispatchTable.CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); + recordFunction(VK_FUNCTION_CREATE_PIPELINE_LAYOUT_MWN, result, device, pCreateInfo, pAllocator, pPipelineLayout); + return result; +} +void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyPipelineLayout(device, pipelineLayout, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_PIPELINE_LAYOUT_MWN, device, pipelineLayout, pAllocator); +} +VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) +{ + auto result = g_dispatchTable.CreateSampler(device, pCreateInfo, pAllocator, pSampler); + recordFunction(VK_FUNCTION_CREATE_SAMPLER_MWN, result, device, pCreateInfo, pAllocator, pSampler); + return result; +} +void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroySampler(device, sampler, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_SAMPLER_MWN, device, sampler, pAllocator); +} +VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) +{ + auto result = g_dispatchTable.CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); + recordFunction(VK_FUNCTION_CREATE_DESCRIPTOR_SET_LAYOUT_MWN, result, device, pCreateInfo, pAllocator, pSetLayout); + return result; +} +void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_DESCRIPTOR_SET_LAYOUT_MWN, device, descriptorSetLayout, pAllocator); +} +VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) +{ + auto result = g_dispatchTable.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); + recordFunction(VK_FUNCTION_CREATE_DESCRIPTOR_POOL_MWN, result, device, pCreateInfo, pAllocator, pDescriptorPool); + return result; +} +void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyDescriptorPool(device, descriptorPool, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_DESCRIPTOR_POOL_MWN, device, descriptorPool, pAllocator); +} +VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) +{ + auto result = g_dispatchTable.ResetDescriptorPool(device, descriptorPool, flags); + recordFunction(VK_FUNCTION_RESET_DESCRIPTOR_POOL_MWN, result, device, descriptorPool, flags); + return result; +} +VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) +{ + auto result = g_dispatchTable.AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); + recordFunction(VK_FUNCTION_ALLOCATE_DESCRIPTOR_SETS_MWN, result, device, pAllocateInfo, pDescriptorSets); + return result; +} +VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) +{ + auto result = g_dispatchTable.FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); + recordFunction(VK_FUNCTION_FREE_DESCRIPTOR_SETS_MWN, result, device, descriptorPool, descriptorSetCount, pDescriptorSets); + return result; +} +void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) +{ + g_dispatchTable.UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); + recordVoidFunction(VK_FUNCTION_UPDATE_DESCRIPTOR_SETS_MWN, device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); +} +VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) +{ + auto result = g_dispatchTable.CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); + recordFunction(VK_FUNCTION_CREATE_FRAMEBUFFER_MWN, result, device, pCreateInfo, pAllocator, pFramebuffer); + return result; +} +void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyFramebuffer(device, framebuffer, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_FRAMEBUFFER_MWN, device, framebuffer, pAllocator); +} +VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + auto result = g_dispatchTable.CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); + recordFunction(VK_FUNCTION_CREATE_RENDER_PASS_MWN, result, device, pCreateInfo, pAllocator, pRenderPass); + return result; +} +void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyRenderPass(device, renderPass, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_RENDER_PASS_MWN, device, renderPass, pAllocator); +} +void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) +{ + g_dispatchTable.GetRenderAreaGranularity(device, renderPass, pGranularity); + recordVoidFunction(VK_FUNCTION_GET_RENDER_AREA_GRANULARITY_MWN, device, renderPass, pGranularity); +} +VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) +{ + auto result = g_dispatchTable.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); + recordFunction(VK_FUNCTION_CREATE_COMMAND_POOL_MWN, result, device, pCreateInfo, pAllocator, pCommandPool); + return result; +} +void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyCommandPool(device, commandPool, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_COMMAND_POOL_MWN, device, commandPool, pAllocator); +} +VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) +{ + auto result = g_dispatchTable.ResetCommandPool(device, commandPool, flags); + recordFunction(VK_FUNCTION_RESET_COMMAND_POOL_MWN, result, device, commandPool, flags); + return result; +} +VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) +{ + auto result = g_dispatchTable.AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); + recordFunction(VK_FUNCTION_ALLOCATE_COMMAND_BUFFERS_MWN, result, device, pAllocateInfo, pCommandBuffers); + return result; +} +void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + g_dispatchTable.FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); + recordVoidFunction(VK_FUNCTION_FREE_COMMAND_BUFFERS_MWN, device, commandPool, commandBufferCount, pCommandBuffers); +} +VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) +{ + auto result = g_dispatchTable.BeginCommandBuffer(commandBuffer, pBeginInfo); + recordFunction(VK_FUNCTION_BEGIN_COMMAND_BUFFER_MWN, result, commandBuffer, pBeginInfo); + return result; +} +VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) +{ + auto result = g_dispatchTable.EndCommandBuffer(commandBuffer); + recordFunction(VK_FUNCTION_END_COMMAND_BUFFER_MWN, result, commandBuffer); + return result; +} +VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) +{ + auto result = g_dispatchTable.ResetCommandBuffer(commandBuffer, flags); + recordFunction(VK_FUNCTION_RESET_COMMAND_BUFFER_MWN, result, commandBuffer, flags); + return result; +} +void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) +{ + g_dispatchTable.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); + recordVoidFunction(VK_FUNCTION_CMD_BIND_PIPELINE_MWN, commandBuffer, pipelineBindPoint, pipeline); +} +void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) +{ + g_dispatchTable.CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); + recordVoidFunction(VK_FUNCTION_CMD_SET_VIEWPORT_MWN, commandBuffer, firstViewport, viewportCount, pViewports); +} +void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) +{ + g_dispatchTable.CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); + recordVoidFunction(VK_FUNCTION_CMD_SET_SCISSOR_MWN, commandBuffer, firstScissor, scissorCount, pScissors); +} +void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) +{ + g_dispatchTable.CmdSetLineWidth(commandBuffer, lineWidth); + recordVoidFunction(VK_FUNCTION_CMD_SET_LINE_WIDTH_MWN, commandBuffer, lineWidth); +} +void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) +{ + g_dispatchTable.CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); + recordVoidFunction(VK_FUNCTION_CMD_SET_DEPTH_BIAS_MWN, commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); +} +void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) +{ + g_dispatchTable.CmdSetBlendConstants(commandBuffer, blendConstants); + recordVoidFunction(VK_FUNCTION_CMD_SET_BLEND_CONSTANTS_MWN, commandBuffer, blendConstants); +} +void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) +{ + g_dispatchTable.CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); + recordVoidFunction(VK_FUNCTION_CMD_SET_DEPTH_BOUNDS_MWN, commandBuffer, minDepthBounds, maxDepthBounds); +} +void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) +{ + g_dispatchTable.CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); + recordVoidFunction(VK_FUNCTION_CMD_SET_STENCIL_COMPARE_MASK_MWN, commandBuffer, faceMask, compareMask); +} +void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) +{ + g_dispatchTable.CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); + recordVoidFunction(VK_FUNCTION_CMD_SET_STENCIL_WRITE_MASK_MWN, commandBuffer, faceMask, writeMask); +} +void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) +{ + g_dispatchTable.CmdSetStencilReference(commandBuffer, faceMask, reference); + recordVoidFunction(VK_FUNCTION_CMD_SET_STENCIL_REFERENCE_MWN, commandBuffer, faceMask, reference); +} +void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) +{ + g_dispatchTable.CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); + recordVoidFunction(VK_FUNCTION_CMD_BIND_DESCRIPTOR_SETS_MWN, commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); +} +void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) +{ + g_dispatchTable.CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); + recordVoidFunction(VK_FUNCTION_CMD_BIND_INDEX_BUFFER_MWN, commandBuffer, buffer, offset, indexType); +} +void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) +{ + g_dispatchTable.CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); + recordVoidFunction(VK_FUNCTION_CMD_BIND_VERTEX_BUFFERS_MWN, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); +} +void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) +{ + g_dispatchTable.CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); + recordVoidFunction(VK_FUNCTION_CMD_DRAW_MWN, commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); +} +void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) +{ + g_dispatchTable.CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); + recordVoidFunction(VK_FUNCTION_CMD_DRAW_INDEXED_MWN, commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); +} +void vkCmdDrawMultiEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawInfoEXT* pVertexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride) +{ + g_dispatchTable.CmdDrawMultiEXT(commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride); + recordVoidFunction(VK_FUNCTION_CMD_DRAW_MULTI_EXT_MWN, commandBuffer, drawCount, pVertexInfo, instanceCount, firstInstance, stride); +} +void vkCmdDrawMultiIndexedEXT(VkCommandBuffer commandBuffer, uint32_t drawCount, const VkMultiDrawIndexedInfoEXT* pIndexInfo, uint32_t instanceCount, uint32_t firstInstance, uint32_t stride, const int32_t* pVertexOffset) +{ + g_dispatchTable.CmdDrawMultiIndexedEXT(commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset); + recordVoidFunction(VK_FUNCTION_CMD_DRAW_MULTI_INDEXED_EXT_MWN, commandBuffer, drawCount, pIndexInfo, instanceCount, firstInstance, stride, pVertexOffset); +} +void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + g_dispatchTable.CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); + recordVoidFunction(VK_FUNCTION_CMD_DRAW_INDIRECT_MWN, commandBuffer, buffer, offset, drawCount, stride); +} +void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + g_dispatchTable.CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); + recordVoidFunction(VK_FUNCTION_CMD_DRAW_INDEXED_INDIRECT_MWN, commandBuffer, buffer, offset, drawCount, stride); +} +void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + g_dispatchTable.CmdDispatch(commandBuffer, groupCountX, groupCountY, groupCountZ); + recordVoidFunction(VK_FUNCTION_CMD_DISPATCH_MWN, commandBuffer, groupCountX, groupCountY, groupCountZ); +} +void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) +{ + g_dispatchTable.CmdDispatchIndirect(commandBuffer, buffer, offset); + recordVoidFunction(VK_FUNCTION_CMD_DISPATCH_INDIRECT_MWN, commandBuffer, buffer, offset); +} +void vkCmdSubpassShadingHUAWEI(VkCommandBuffer commandBuffer) +{ + g_dispatchTable.CmdSubpassShadingHUAWEI(commandBuffer); + recordVoidFunction(VK_FUNCTION_CMD_SUBPASS_SHADING_HUAWEI_MWN, commandBuffer); +} +void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) +{ + g_dispatchTable.CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); + recordVoidFunction(VK_FUNCTION_CMD_COPY_BUFFER_MWN, commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); +} +void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) +{ + g_dispatchTable.CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); + recordVoidFunction(VK_FUNCTION_CMD_COPY_IMAGE_MWN, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); +} +void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) +{ + g_dispatchTable.CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); + recordVoidFunction(VK_FUNCTION_CMD_BLIT_IMAGE_MWN, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); +} +void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + g_dispatchTable.CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); + recordVoidFunction(VK_FUNCTION_CMD_COPY_BUFFER_TO_IMAGE_MWN, commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); +} +void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) +{ + g_dispatchTable.CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); + recordVoidFunction(VK_FUNCTION_CMD_COPY_IMAGE_TO_BUFFER_MWN, commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); +} +void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const void* pData) +{ + g_dispatchTable.CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); + recordVoidFunction(VK_FUNCTION_CMD_UPDATE_BUFFER_MWN, commandBuffer, dstBuffer, dstOffset, dataSize, pData); +} +void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) +{ + g_dispatchTable.CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); + recordVoidFunction(VK_FUNCTION_CMD_FILL_BUFFER_MWN, commandBuffer, dstBuffer, dstOffset, size, data); +} +void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + g_dispatchTable.CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); + recordVoidFunction(VK_FUNCTION_CMD_CLEAR_COLOR_IMAGE_MWN, commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); +} +void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) +{ + g_dispatchTable.CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); + recordVoidFunction(VK_FUNCTION_CMD_CLEAR_DEPTH_STENCIL_IMAGE_MWN, commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); +} +void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) +{ + g_dispatchTable.CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); + recordVoidFunction(VK_FUNCTION_CMD_CLEAR_ATTACHMENTS_MWN, commandBuffer, attachmentCount, pAttachments, rectCount, pRects); +} +void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) +{ + g_dispatchTable.CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); + recordVoidFunction(VK_FUNCTION_CMD_RESOLVE_IMAGE_MWN, commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); +} +void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + g_dispatchTable.CmdSetEvent(commandBuffer, event, stageMask); + recordVoidFunction(VK_FUNCTION_CMD_SET_EVENT_MWN, commandBuffer, event, stageMask); +} +void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) +{ + g_dispatchTable.CmdResetEvent(commandBuffer, event, stageMask); + recordVoidFunction(VK_FUNCTION_CMD_RESET_EVENT_MWN, commandBuffer, event, stageMask); +} +void vkCmdWaitEvents(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) +{ + g_dispatchTable.CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); + recordVoidFunction(VK_FUNCTION_CMD_WAIT_EVENTS_MWN, commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); +} +void vkCmdPipelineBarrier(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) +{ + g_dispatchTable.CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); + recordVoidFunction(VK_FUNCTION_CMD_PIPELINE_BARRIER_MWN, commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); +} +void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) +{ + g_dispatchTable.CmdBeginQuery(commandBuffer, queryPool, query, flags); + recordVoidFunction(VK_FUNCTION_CMD_BEGIN_QUERY_MWN, commandBuffer, queryPool, query, flags); +} +void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) +{ + g_dispatchTable.CmdEndQuery(commandBuffer, queryPool, query); + recordVoidFunction(VK_FUNCTION_CMD_END_QUERY_MWN, commandBuffer, queryPool, query); +} +void vkCmdBeginConditionalRenderingEXT(VkCommandBuffer commandBuffer, const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) +{ + g_dispatchTable.CmdBeginConditionalRenderingEXT(commandBuffer, pConditionalRenderingBegin); + recordVoidFunction(VK_FUNCTION_CMD_BEGIN_CONDITIONAL_RENDERING_EXT_MWN, commandBuffer, pConditionalRenderingBegin); +} +void vkCmdEndConditionalRenderingEXT(VkCommandBuffer commandBuffer) +{ + g_dispatchTable.CmdEndConditionalRenderingEXT(commandBuffer); + recordVoidFunction(VK_FUNCTION_CMD_END_CONDITIONAL_RENDERING_EXT_MWN, commandBuffer); +} +void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) +{ + g_dispatchTable.CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); + recordVoidFunction(VK_FUNCTION_CMD_RESET_QUERY_POOL_MWN, commandBuffer, queryPool, firstQuery, queryCount); +} +void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) +{ + g_dispatchTable.CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); + recordVoidFunction(VK_FUNCTION_CMD_WRITE_TIMESTAMP_MWN, commandBuffer, pipelineStage, queryPool, query); +} +void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) +{ + g_dispatchTable.CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); + recordVoidFunction(VK_FUNCTION_CMD_COPY_QUERY_POOL_RESULTS_MWN, commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); +} +void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) +{ + g_dispatchTable.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); + recordVoidFunction(VK_FUNCTION_CMD_PUSH_CONSTANTS_MWN, commandBuffer, layout, stageFlags, offset, size, pValues); +} +void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) +{ + g_dispatchTable.CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); + recordVoidFunction(VK_FUNCTION_CMD_BEGIN_RENDER_PASS_MWN, commandBuffer, pRenderPassBegin, contents); +} +void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) +{ + g_dispatchTable.CmdNextSubpass(commandBuffer, contents); + recordVoidFunction(VK_FUNCTION_CMD_NEXT_SUBPASS_MWN, commandBuffer, contents); +} +void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) +{ + g_dispatchTable.CmdEndRenderPass(commandBuffer); + recordVoidFunction(VK_FUNCTION_CMD_END_RENDER_PASS_MWN, commandBuffer); +} +void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) +{ + g_dispatchTable.CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); + recordVoidFunction(VK_FUNCTION_CMD_EXECUTE_COMMANDS_MWN, commandBuffer, commandBufferCount, pCommandBuffers); +} +VkResult vkCreateSharedSwapchainsKHR(VkDevice device, uint32_t swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) +{ + auto result = g_dispatchTable.CreateSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); + recordFunction(VK_FUNCTION_CREATE_SHARED_SWAPCHAINS_KHR_MWN, result, device, swapchainCount, pCreateInfos, pAllocator, pSwapchains); + return result; +} +VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) +{ + auto result = g_dispatchTable.CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); + recordFunction(VK_FUNCTION_CREATE_SWAPCHAIN_KHR_MWN, result, device, pCreateInfo, pAllocator, pSwapchain); + return result; +} +void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroySwapchainKHR(device, swapchain, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_SWAPCHAIN_KHR_MWN, device, swapchain, pAllocator); +} +VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) +{ + auto result = g_dispatchTable.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); + recordFunction(VK_FUNCTION_GET_SWAPCHAIN_IMAGES_KHR_MWN, result, device, swapchain, pSwapchainImageCount, pSwapchainImages); + return result; +} +VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) +{ + auto result = g_dispatchTable.AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); + recordFunction(VK_FUNCTION_ACQUIRE_NEXT_IMAGE_KHR_MWN, result, device, swapchain, timeout, semaphore, fence, pImageIndex); + return result; +} +VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) +{ + auto result = g_dispatchTable.QueuePresentKHR(queue, pPresentInfo); + recordFunction(VK_FUNCTION_QUEUE_PRESENT_KHR_MWN, result, queue, pPresentInfo); + return result; +} +VkResult vkDebugMarkerSetObjectNameEXT(VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) +{ + auto result = g_dispatchTable.DebugMarkerSetObjectNameEXT(device, pNameInfo); + recordFunction(VK_FUNCTION_DEBUG_MARKER_SET_OBJECT_NAME_EXT_MWN, result, device, pNameInfo); + return result; +} +VkResult vkDebugMarkerSetObjectTagEXT(VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) +{ + auto result = g_dispatchTable.DebugMarkerSetObjectTagEXT(device, pTagInfo); + recordFunction(VK_FUNCTION_DEBUG_MARKER_SET_OBJECT_TAG_EXT_MWN, result, device, pTagInfo); + return result; +} +void vkCmdDebugMarkerBeginEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) +{ + g_dispatchTable.CmdDebugMarkerBeginEXT(commandBuffer, pMarkerInfo); + recordVoidFunction(VK_FUNCTION_CMD_DEBUG_MARKER_BEGIN_EXT_MWN, commandBuffer, pMarkerInfo); +} +void vkCmdDebugMarkerEndEXT(VkCommandBuffer commandBuffer) +{ + g_dispatchTable.CmdDebugMarkerEndEXT(commandBuffer); + recordVoidFunction(VK_FUNCTION_CMD_DEBUG_MARKER_END_EXT_MWN, commandBuffer); +} +void vkCmdDebugMarkerInsertEXT(VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) +{ + g_dispatchTable.CmdDebugMarkerInsertEXT(commandBuffer, pMarkerInfo); + recordVoidFunction(VK_FUNCTION_CMD_DEBUG_MARKER_INSERT_EXT_MWN, commandBuffer, pMarkerInfo); +} +void vkCmdExecuteGeneratedCommandsNV(VkCommandBuffer commandBuffer, VkBool32 isPreprocessed, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) +{ + g_dispatchTable.CmdExecuteGeneratedCommandsNV(commandBuffer, isPreprocessed, pGeneratedCommandsInfo); + recordVoidFunction(VK_FUNCTION_CMD_EXECUTE_GENERATED_COMMANDS_NV_MWN, commandBuffer, isPreprocessed, pGeneratedCommandsInfo); +} +void vkCmdPreprocessGeneratedCommandsNV(VkCommandBuffer commandBuffer, const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) +{ + g_dispatchTable.CmdPreprocessGeneratedCommandsNV(commandBuffer, pGeneratedCommandsInfo); + recordVoidFunction(VK_FUNCTION_CMD_PREPROCESS_GENERATED_COMMANDS_NV_MWN, commandBuffer, pGeneratedCommandsInfo); +} +void vkCmdBindPipelineShaderGroupNV(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline, uint32_t groupIndex) +{ + g_dispatchTable.CmdBindPipelineShaderGroupNV(commandBuffer, pipelineBindPoint, pipeline, groupIndex); + recordVoidFunction(VK_FUNCTION_CMD_BIND_PIPELINE_SHADER_GROUP_NV_MWN, commandBuffer, pipelineBindPoint, pipeline, groupIndex); +} +void vkGetGeneratedCommandsMemoryRequirementsNV(VkDevice device, const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + g_dispatchTable.GetGeneratedCommandsMemoryRequirementsNV(device, pInfo, pMemoryRequirements); + recordVoidFunction(VK_FUNCTION_GET_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_NV_MWN, device, pInfo, pMemoryRequirements); +} +VkResult vkCreateIndirectCommandsLayoutNV(VkDevice device, const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) +{ + auto result = g_dispatchTable.CreateIndirectCommandsLayoutNV(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); + recordFunction(VK_FUNCTION_CREATE_INDIRECT_COMMANDS_LAYOUT_NV_MWN, result, device, pCreateInfo, pAllocator, pIndirectCommandsLayout); + return result; +} +void vkDestroyIndirectCommandsLayoutNV(VkDevice device, VkIndirectCommandsLayoutNV indirectCommandsLayout, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyIndirectCommandsLayoutNV(device, indirectCommandsLayout, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_INDIRECT_COMMANDS_LAYOUT_NV_MWN, device, indirectCommandsLayout, pAllocator); +} +void vkCmdPushDescriptorSetKHR(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t set, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) +{ + g_dispatchTable.CmdPushDescriptorSetKHR(commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); + recordVoidFunction(VK_FUNCTION_CMD_PUSH_DESCRIPTOR_SET_KHR_MWN, commandBuffer, pipelineBindPoint, layout, set, descriptorWriteCount, pDescriptorWrites); +} +void vkTrimCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) +{ + g_dispatchTable.TrimCommandPool(device, commandPool, flags); + recordVoidFunction(VK_FUNCTION_TRIM_COMMAND_POOL_MWN, device, commandPool, flags); +} +VkResult vkGetMemoryFdKHR(VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) +{ + auto result = g_dispatchTable.GetMemoryFdKHR(device, pGetFdInfo, pFd); + recordFunction(VK_FUNCTION_GET_MEMORY_FD_KHR_MWN, result, device, pGetFdInfo, pFd); + return result; +} +VkResult vkGetMemoryFdPropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, int fd, VkMemoryFdPropertiesKHR* pMemoryFdProperties) +{ + auto result = g_dispatchTable.GetMemoryFdPropertiesKHR(device, handleType, fd, pMemoryFdProperties); + recordFunction(VK_FUNCTION_GET_MEMORY_FD_PROPERTIES_KHR_MWN, result, device, handleType, fd, pMemoryFdProperties); + return result; +} +VkResult vkGetMemoryRemoteAddressNV(VkDevice device, const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, VkRemoteAddressNV* pAddress) +{ + auto result = g_dispatchTable.GetMemoryRemoteAddressNV(device, pMemoryGetRemoteAddressInfo, pAddress); + recordFunction(VK_FUNCTION_GET_MEMORY_REMOTE_ADDRESS_NV_MWN, result, device, pMemoryGetRemoteAddressInfo, pAddress); + return result; +} +VkResult vkGetSemaphoreFdKHR(VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) +{ + auto result = g_dispatchTable.GetSemaphoreFdKHR(device, pGetFdInfo, pFd); + recordFunction(VK_FUNCTION_GET_SEMAPHORE_FD_KHR_MWN, result, device, pGetFdInfo, pFd); + return result; +} +VkResult vkImportSemaphoreFdKHR(VkDevice device, const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) +{ + auto result = g_dispatchTable.ImportSemaphoreFdKHR(device, pImportSemaphoreFdInfo); + recordFunction(VK_FUNCTION_IMPORT_SEMAPHORE_FD_KHR_MWN, result, device, pImportSemaphoreFdInfo); + return result; +} +VkResult vkGetFenceFdKHR(VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) +{ + auto result = g_dispatchTable.GetFenceFdKHR(device, pGetFdInfo, pFd); + recordFunction(VK_FUNCTION_GET_FENCE_FD_KHR_MWN, result, device, pGetFdInfo, pFd); + return result; +} +VkResult vkImportFenceFdKHR(VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) +{ + auto result = g_dispatchTable.ImportFenceFdKHR(device, pImportFenceFdInfo); + recordFunction(VK_FUNCTION_IMPORT_FENCE_FD_KHR_MWN, result, device, pImportFenceFdInfo); + return result; +} +VkResult vkDisplayPowerControlEXT(VkDevice device, VkDisplayKHR display, const VkDisplayPowerInfoEXT* pDisplayPowerInfo) +{ + auto result = g_dispatchTable.DisplayPowerControlEXT(device, display, pDisplayPowerInfo); + recordFunction(VK_FUNCTION_DISPLAY_POWER_CONTROL_EXT_MWN, result, device, display, pDisplayPowerInfo); + return result; +} +VkResult vkRegisterDeviceEventEXT(VkDevice device, const VkDeviceEventInfoEXT* pDeviceEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + auto result = g_dispatchTable.RegisterDeviceEventEXT(device, pDeviceEventInfo, pAllocator, pFence); + recordFunction(VK_FUNCTION_REGISTER_DEVICE_EVENT_EXT_MWN, result, device, pDeviceEventInfo, pAllocator, pFence); + return result; +} +VkResult vkRegisterDisplayEventEXT(VkDevice device, VkDisplayKHR display, const VkDisplayEventInfoEXT* pDisplayEventInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) +{ + auto result = g_dispatchTable.RegisterDisplayEventEXT(device, display, pDisplayEventInfo, pAllocator, pFence); + recordFunction(VK_FUNCTION_REGISTER_DISPLAY_EVENT_EXT_MWN, result, device, display, pDisplayEventInfo, pAllocator, pFence); + return result; +} +VkResult vkGetSwapchainCounterEXT(VkDevice device, VkSwapchainKHR swapchain, VkSurfaceCounterFlagBitsEXT counter, uint64_t* pCounterValue) +{ + auto result = g_dispatchTable.GetSwapchainCounterEXT(device, swapchain, counter, pCounterValue); + recordFunction(VK_FUNCTION_GET_SWAPCHAIN_COUNTER_EXT_MWN, result, device, swapchain, counter, pCounterValue); + return result; +} +void vkGetDeviceGroupPeerMemoryFeatures(VkDevice device, uint32_t heapIndex, uint32_t localDeviceIndex, uint32_t remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ + g_dispatchTable.GetDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); + recordVoidFunction(VK_FUNCTION_GET_DEVICE_GROUP_PEER_MEMORY_FEATURES_MWN, device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures); +} +VkResult vkBindBufferMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) +{ + auto result = g_dispatchTable.BindBufferMemory2(device, bindInfoCount, pBindInfos); + recordFunction(VK_FUNCTION_BIND_BUFFER_MEMORY2_MWN, result, device, bindInfoCount, pBindInfos); + return result; +} +VkResult vkBindImageMemory2(VkDevice device, uint32_t bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) +{ + auto result = g_dispatchTable.BindImageMemory2(device, bindInfoCount, pBindInfos); + recordFunction(VK_FUNCTION_BIND_IMAGE_MEMORY2_MWN, result, device, bindInfoCount, pBindInfos); + return result; +} +void vkCmdSetDeviceMask(VkCommandBuffer commandBuffer, uint32_t deviceMask) +{ + g_dispatchTable.CmdSetDeviceMask(commandBuffer, deviceMask); + recordVoidFunction(VK_FUNCTION_CMD_SET_DEVICE_MASK_MWN, commandBuffer, deviceMask); +} +VkResult vkGetDeviceGroupPresentCapabilitiesKHR(VkDevice device, VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) +{ + auto result = g_dispatchTable.GetDeviceGroupPresentCapabilitiesKHR(device, pDeviceGroupPresentCapabilities); + recordFunction(VK_FUNCTION_GET_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR_MWN, result, device, pDeviceGroupPresentCapabilities); + return result; +} +VkResult vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, VkDeviceGroupPresentModeFlagsKHR* pModes) +{ + auto result = g_dispatchTable.GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); + recordFunction(VK_FUNCTION_GET_DEVICE_GROUP_SURFACE_PRESENT_MODES_KHR_MWN, result, device, surface, pModes); + return result; +} +VkResult vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, uint32_t* pImageIndex) +{ + auto result = g_dispatchTable.AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); + recordFunction(VK_FUNCTION_ACQUIRE_NEXT_IMAGE2_KHR_MWN, result, device, pAcquireInfo, pImageIndex); + return result; +} +void vkCmdDispatchBase(VkCommandBuffer commandBuffer, uint32_t baseGroupX, uint32_t baseGroupY, uint32_t baseGroupZ, uint32_t groupCountX, uint32_t groupCountY, uint32_t groupCountZ) +{ + g_dispatchTable.CmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); + recordVoidFunction(VK_FUNCTION_CMD_DISPATCH_BASE_MWN, commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ); +} +VkResult vkCreateDescriptorUpdateTemplate(VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + auto result = g_dispatchTable.CreateDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + recordFunction(VK_FUNCTION_CREATE_DESCRIPTOR_UPDATE_TEMPLATE_MWN, result, device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate); + return result; +} +void vkDestroyDescriptorUpdateTemplate(VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_DESCRIPTOR_UPDATE_TEMPLATE_MWN, device, descriptorUpdateTemplate, pAllocator); +} +void vkUpdateDescriptorSetWithTemplate(VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) +{ + g_dispatchTable.UpdateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData); + recordVoidFunction(VK_FUNCTION_UPDATE_DESCRIPTOR_SET_WITH_TEMPLATE_MWN, device, descriptorSet, descriptorUpdateTemplate, pData); +} +void vkCmdPushDescriptorSetWithTemplateKHR(VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, uint32_t set, const void* pData) +{ + g_dispatchTable.CmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData); + recordVoidFunction(VK_FUNCTION_CMD_PUSH_DESCRIPTOR_SET_WITH_TEMPLATE_KHR_MWN, commandBuffer, descriptorUpdateTemplate, layout, set, pData); +} +void vkSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) +{ + g_dispatchTable.SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata); + recordVoidFunction(VK_FUNCTION_SET_HDR_METADATA_EXT_MWN, device, swapchainCount, pSwapchains, pMetadata); +} +VkResult vkGetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain) +{ + auto result = g_dispatchTable.GetSwapchainStatusKHR(device, swapchain); + recordFunction(VK_FUNCTION_GET_SWAPCHAIN_STATUS_KHR_MWN, result, device, swapchain); + return result; +} +VkResult vkGetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) +{ + auto result = g_dispatchTable.GetRefreshCycleDurationGOOGLE(device, swapchain, pDisplayTimingProperties); + recordFunction(VK_FUNCTION_GET_REFRESH_CYCLE_DURATION_GOOGLE_MWN, result, device, swapchain, pDisplayTimingProperties); + return result; +} +VkResult vkGetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings) +{ + auto result = g_dispatchTable.GetPastPresentationTimingGOOGLE(device, swapchain, pPresentationTimingCount, pPresentationTimings); + recordFunction(VK_FUNCTION_GET_PAST_PRESENTATION_TIMING_GOOGLE_MWN, result, device, swapchain, pPresentationTimingCount, pPresentationTimings); + return result; +} +void vkCmdSetViewportWScalingNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewportWScalingNV* pViewportWScalings) +{ + g_dispatchTable.CmdSetViewportWScalingNV(commandBuffer, firstViewport, viewportCount, pViewportWScalings); + recordVoidFunction(VK_FUNCTION_CMD_SET_VIEWPORT_WSCALING_NV_MWN, commandBuffer, firstViewport, viewportCount, pViewportWScalings); +} +void vkCmdSetDiscardRectangleEXT(VkCommandBuffer commandBuffer, uint32_t firstDiscardRectangle, uint32_t discardRectangleCount, const VkRect2D* pDiscardRectangles) +{ + g_dispatchTable.CmdSetDiscardRectangleEXT(commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); + recordVoidFunction(VK_FUNCTION_CMD_SET_DISCARD_RECTANGLE_EXT_MWN, commandBuffer, firstDiscardRectangle, discardRectangleCount, pDiscardRectangles); +} +void vkCmdSetSampleLocationsEXT(VkCommandBuffer commandBuffer, const VkSampleLocationsInfoEXT* pSampleLocationsInfo) +{ + g_dispatchTable.CmdSetSampleLocationsEXT(commandBuffer, pSampleLocationsInfo); + recordVoidFunction(VK_FUNCTION_CMD_SET_SAMPLE_LOCATIONS_EXT_MWN, commandBuffer, pSampleLocationsInfo); +} +void vkGetBufferMemoryRequirements2(VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + g_dispatchTable.GetBufferMemoryRequirements2(device, pInfo, pMemoryRequirements); + recordVoidFunction(VK_FUNCTION_GET_BUFFER_MEMORY_REQUIREMENTS2_MWN, device, pInfo, pMemoryRequirements); +} +void vkGetImageMemoryRequirements2(VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + g_dispatchTable.GetImageMemoryRequirements2(device, pInfo, pMemoryRequirements); + recordVoidFunction(VK_FUNCTION_GET_IMAGE_MEMORY_REQUIREMENTS2_MWN, device, pInfo, pMemoryRequirements); +} +void vkGetImageSparseMemoryRequirements2(VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + g_dispatchTable.GetImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + recordVoidFunction(VK_FUNCTION_GET_IMAGE_SPARSE_MEMORY_REQUIREMENTS2_MWN, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} +void vkGetDeviceBufferMemoryRequirements(VkDevice device, const VkDeviceBufferMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + g_dispatchTable.GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); + recordVoidFunction(VK_FUNCTION_GET_DEVICE_BUFFER_MEMORY_REQUIREMENTS_MWN, device, pInfo, pMemoryRequirements); +} +void vkGetDeviceImageMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, VkMemoryRequirements2* pMemoryRequirements) +{ + g_dispatchTable.GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); + recordVoidFunction(VK_FUNCTION_GET_DEVICE_IMAGE_MEMORY_REQUIREMENTS_MWN, device, pInfo, pMemoryRequirements); +} +void vkGetDeviceImageSparseMemoryRequirements(VkDevice device, const VkDeviceImageMemoryRequirements* pInfo, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + g_dispatchTable.GetDeviceImageSparseMemoryRequirements(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); + recordVoidFunction(VK_FUNCTION_GET_DEVICE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_MWN, device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} +VkResult vkCreateSamplerYcbcrConversion(VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) +{ + auto result = g_dispatchTable.CreateSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion); + recordFunction(VK_FUNCTION_CREATE_SAMPLER_YCBCR_CONVERSION_MWN, result, device, pCreateInfo, pAllocator, pYcbcrConversion); + return result; +} +void vkDestroySamplerYcbcrConversion(VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_SAMPLER_YCBCR_CONVERSION_MWN, device, ycbcrConversion, pAllocator); +} +void vkGetDeviceQueue2(VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) +{ + g_dispatchTable.GetDeviceQueue2(device, pQueueInfo, pQueue); + recordVoidFunction(VK_FUNCTION_GET_DEVICE_QUEUE2_MWN, device, pQueueInfo, pQueue); +} +VkResult vkCreateValidationCacheEXT(VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkValidationCacheEXT* pValidationCache) +{ + auto result = g_dispatchTable.CreateValidationCacheEXT(device, pCreateInfo, pAllocator, pValidationCache); + recordFunction(VK_FUNCTION_CREATE_VALIDATION_CACHE_EXT_MWN, result, device, pCreateInfo, pAllocator, pValidationCache); + return result; +} +void vkDestroyValidationCacheEXT(VkDevice device, VkValidationCacheEXT validationCache, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyValidationCacheEXT(device, validationCache, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_VALIDATION_CACHE_EXT_MWN, device, validationCache, pAllocator); +} +VkResult vkGetValidationCacheDataEXT(VkDevice device, VkValidationCacheEXT validationCache, size_t* pDataSize, void* pData) +{ + auto result = g_dispatchTable.GetValidationCacheDataEXT(device, validationCache, pDataSize, pData); + recordFunction(VK_FUNCTION_GET_VALIDATION_CACHE_DATA_EXT_MWN, result, device, validationCache, pDataSize, pData); + return result; +} +VkResult vkMergeValidationCachesEXT(VkDevice device, VkValidationCacheEXT dstCache, uint32_t srcCacheCount, const VkValidationCacheEXT* pSrcCaches) +{ + auto result = g_dispatchTable.MergeValidationCachesEXT(device, dstCache, srcCacheCount, pSrcCaches); + recordFunction(VK_FUNCTION_MERGE_VALIDATION_CACHES_EXT_MWN, result, device, dstCache, srcCacheCount, pSrcCaches); + return result; +} +void vkGetDescriptorSetLayoutSupport(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) +{ + g_dispatchTable.GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); + recordVoidFunction(VK_FUNCTION_GET_DESCRIPTOR_SET_LAYOUT_SUPPORT_MWN, device, pCreateInfo, pSupport); +} +VkResult vkGetShaderInfoAMD(VkDevice device, VkPipeline pipeline, VkShaderStageFlagBits shaderStage, VkShaderInfoTypeAMD infoType, size_t* pInfoSize, void* pInfo) +{ + auto result = g_dispatchTable.GetShaderInfoAMD(device, pipeline, shaderStage, infoType, pInfoSize, pInfo); + recordFunction(VK_FUNCTION_GET_SHADER_INFO_AMD_MWN, result, device, pipeline, shaderStage, infoType, pInfoSize, pInfo); + return result; +} +void vkSetLocalDimmingAMD(VkDevice device, VkSwapchainKHR swapChain, VkBool32 localDimmingEnable) +{ + g_dispatchTable.SetLocalDimmingAMD(device, swapChain, localDimmingEnable); + recordVoidFunction(VK_FUNCTION_SET_LOCAL_DIMMING_AMD_MWN, device, swapChain, localDimmingEnable); +} +VkResult vkGetCalibratedTimestampsEXT(VkDevice device, uint32_t timestampCount, const VkCalibratedTimestampInfoEXT* pTimestampInfos, uint64_t* pTimestamps, uint64_t* pMaxDeviation) +{ + auto result = g_dispatchTable.GetCalibratedTimestampsEXT(device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); + recordFunction(VK_FUNCTION_GET_CALIBRATED_TIMESTAMPS_EXT_MWN, result, device, timestampCount, pTimestampInfos, pTimestamps, pMaxDeviation); + return result; +} +VkResult vkSetDebugUtilsObjectNameEXT(VkDevice device, const VkDebugUtilsObjectNameInfoEXT* pNameInfo) +{ + auto result = g_dispatchTable.SetDebugUtilsObjectNameEXT(device, pNameInfo); + recordFunction(VK_FUNCTION_SET_DEBUG_UTILS_OBJECT_NAME_EXT_MWN, result, device, pNameInfo); + return result; +} +VkResult vkSetDebugUtilsObjectTagEXT(VkDevice device, const VkDebugUtilsObjectTagInfoEXT* pTagInfo) +{ + auto result = g_dispatchTable.SetDebugUtilsObjectTagEXT(device, pTagInfo); + recordFunction(VK_FUNCTION_SET_DEBUG_UTILS_OBJECT_TAG_EXT_MWN, result, device, pTagInfo); + return result; +} +void vkQueueBeginDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) +{ + g_dispatchTable.QueueBeginDebugUtilsLabelEXT(queue, pLabelInfo); + recordVoidFunction(VK_FUNCTION_QUEUE_BEGIN_DEBUG_UTILS_LABEL_EXT_MWN, queue, pLabelInfo); +} +void vkQueueEndDebugUtilsLabelEXT(VkQueue queue) +{ + g_dispatchTable.QueueEndDebugUtilsLabelEXT(queue); + recordVoidFunction(VK_FUNCTION_QUEUE_END_DEBUG_UTILS_LABEL_EXT_MWN, queue); +} +void vkQueueInsertDebugUtilsLabelEXT(VkQueue queue, const VkDebugUtilsLabelEXT* pLabelInfo) +{ + g_dispatchTable.QueueInsertDebugUtilsLabelEXT(queue, pLabelInfo); + recordVoidFunction(VK_FUNCTION_QUEUE_INSERT_DEBUG_UTILS_LABEL_EXT_MWN, queue, pLabelInfo); +} +void vkCmdBeginDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) +{ + g_dispatchTable.CmdBeginDebugUtilsLabelEXT(commandBuffer, pLabelInfo); + recordVoidFunction(VK_FUNCTION_CMD_BEGIN_DEBUG_UTILS_LABEL_EXT_MWN, commandBuffer, pLabelInfo); +} +void vkCmdEndDebugUtilsLabelEXT(VkCommandBuffer commandBuffer) +{ + g_dispatchTable.CmdEndDebugUtilsLabelEXT(commandBuffer); + recordVoidFunction(VK_FUNCTION_CMD_END_DEBUG_UTILS_LABEL_EXT_MWN, commandBuffer); +} +void vkCmdInsertDebugUtilsLabelEXT(VkCommandBuffer commandBuffer, const VkDebugUtilsLabelEXT* pLabelInfo) +{ + g_dispatchTable.CmdInsertDebugUtilsLabelEXT(commandBuffer, pLabelInfo); + recordVoidFunction(VK_FUNCTION_CMD_INSERT_DEBUG_UTILS_LABEL_EXT_MWN, commandBuffer, pLabelInfo); +} +VkResult vkGetMemoryHostPointerPropertiesEXT(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, const void* pHostPointer, VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) +{ + auto result = g_dispatchTable.GetMemoryHostPointerPropertiesEXT(device, handleType, pHostPointer, pMemoryHostPointerProperties); + recordFunction(VK_FUNCTION_GET_MEMORY_HOST_POINTER_PROPERTIES_EXT_MWN, result, device, handleType, pHostPointer, pMemoryHostPointerProperties); + return result; +} +void vkCmdWriteBufferMarkerAMD(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) +{ + g_dispatchTable.CmdWriteBufferMarkerAMD(commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); + recordVoidFunction(VK_FUNCTION_CMD_WRITE_BUFFER_MARKER_AMD_MWN, commandBuffer, pipelineStage, dstBuffer, dstOffset, marker); +} +VkResult vkCreateRenderPass2(VkDevice device, const VkRenderPassCreateInfo2* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) +{ + auto result = g_dispatchTable.CreateRenderPass2(device, pCreateInfo, pAllocator, pRenderPass); + recordFunction(VK_FUNCTION_CREATE_RENDER_PASS2_MWN, result, device, pCreateInfo, pAllocator, pRenderPass); + return result; +} +void vkCmdBeginRenderPass2(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, const VkSubpassBeginInfo* pSubpassBeginInfo) +{ + g_dispatchTable.CmdBeginRenderPass2(commandBuffer, pRenderPassBegin, pSubpassBeginInfo); + recordVoidFunction(VK_FUNCTION_CMD_BEGIN_RENDER_PASS2_MWN, commandBuffer, pRenderPassBegin, pSubpassBeginInfo); +} +void vkCmdNextSubpass2(VkCommandBuffer commandBuffer, const VkSubpassBeginInfo* pSubpassBeginInfo, const VkSubpassEndInfo* pSubpassEndInfo) +{ + g_dispatchTable.CmdNextSubpass2(commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); + recordVoidFunction(VK_FUNCTION_CMD_NEXT_SUBPASS2_MWN, commandBuffer, pSubpassBeginInfo, pSubpassEndInfo); +} +void vkCmdEndRenderPass2(VkCommandBuffer commandBuffer, const VkSubpassEndInfo* pSubpassEndInfo) +{ + g_dispatchTable.CmdEndRenderPass2(commandBuffer, pSubpassEndInfo); + recordVoidFunction(VK_FUNCTION_CMD_END_RENDER_PASS2_MWN, commandBuffer, pSubpassEndInfo); +} +VkResult vkGetSemaphoreCounterValue(VkDevice device, VkSemaphore semaphore, uint64_t* pValue) +{ + auto result = g_dispatchTable.GetSemaphoreCounterValue(device, semaphore, pValue); + recordFunction(VK_FUNCTION_GET_SEMAPHORE_COUNTER_VALUE_MWN, result, device, semaphore, pValue); + return result; +} +VkResult vkWaitSemaphores(VkDevice device, const VkSemaphoreWaitInfo* pWaitInfo, uint64_t timeout) +{ + auto result = g_dispatchTable.WaitSemaphores(device, pWaitInfo, timeout); + recordFunction(VK_FUNCTION_WAIT_SEMAPHORES_MWN, result, device, pWaitInfo, timeout); + return result; +} +VkResult vkSignalSemaphore(VkDevice device, const VkSemaphoreSignalInfo* pSignalInfo) +{ + auto result = g_dispatchTable.SignalSemaphore(device, pSignalInfo); + recordFunction(VK_FUNCTION_SIGNAL_SEMAPHORE_MWN, result, device, pSignalInfo); + return result; +} +void vkCmdDrawIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + g_dispatchTable.CmdDrawIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + recordVoidFunction(VK_FUNCTION_CMD_DRAW_INDIRECT_COUNT_MWN, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} +void vkCmdDrawIndexedIndirectCount(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + g_dispatchTable.CmdDrawIndexedIndirectCount(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + recordVoidFunction(VK_FUNCTION_CMD_DRAW_INDEXED_INDIRECT_COUNT_MWN, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} +void vkCmdSetCheckpointNV(VkCommandBuffer commandBuffer, const void* pCheckpointMarker) +{ + g_dispatchTable.CmdSetCheckpointNV(commandBuffer, pCheckpointMarker); + recordVoidFunction(VK_FUNCTION_CMD_SET_CHECKPOINT_NV_MWN, commandBuffer, pCheckpointMarker); +} +void vkGetQueueCheckpointDataNV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointDataNV* pCheckpointData) +{ + g_dispatchTable.GetQueueCheckpointDataNV(queue, pCheckpointDataCount, pCheckpointData); + recordVoidFunction(VK_FUNCTION_GET_QUEUE_CHECKPOINT_DATA_NV_MWN, queue, pCheckpointDataCount, pCheckpointData); +} +void vkCmdBindTransformFeedbackBuffersEXT(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes) +{ + g_dispatchTable.CmdBindTransformFeedbackBuffersEXT(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); + recordVoidFunction(VK_FUNCTION_CMD_BIND_TRANSFORM_FEEDBACK_BUFFERS_EXT_MWN, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes); +} +void vkCmdBeginTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + g_dispatchTable.CmdBeginTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + recordVoidFunction(VK_FUNCTION_CMD_BEGIN_TRANSFORM_FEEDBACK_EXT_MWN, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); +} +void vkCmdEndTransformFeedbackEXT(VkCommandBuffer commandBuffer, uint32_t firstCounterBuffer, uint32_t counterBufferCount, const VkBuffer* pCounterBuffers, const VkDeviceSize* pCounterBufferOffsets) +{ + g_dispatchTable.CmdEndTransformFeedbackEXT(commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); + recordVoidFunction(VK_FUNCTION_CMD_END_TRANSFORM_FEEDBACK_EXT_MWN, commandBuffer, firstCounterBuffer, counterBufferCount, pCounterBuffers, pCounterBufferOffsets); +} +void vkCmdBeginQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags, uint32_t index) +{ + g_dispatchTable.CmdBeginQueryIndexedEXT(commandBuffer, queryPool, query, flags, index); + recordVoidFunction(VK_FUNCTION_CMD_BEGIN_QUERY_INDEXED_EXT_MWN, commandBuffer, queryPool, query, flags, index); +} +void vkCmdEndQueryIndexedEXT(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, uint32_t index) +{ + g_dispatchTable.CmdEndQueryIndexedEXT(commandBuffer, queryPool, query, index); + recordVoidFunction(VK_FUNCTION_CMD_END_QUERY_INDEXED_EXT_MWN, commandBuffer, queryPool, query, index); +} +void vkCmdDrawIndirectByteCountEXT(VkCommandBuffer commandBuffer, uint32_t instanceCount, uint32_t firstInstance, VkBuffer counterBuffer, VkDeviceSize counterBufferOffset, uint32_t counterOffset, uint32_t vertexStride) +{ + g_dispatchTable.CmdDrawIndirectByteCountEXT(commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); + recordVoidFunction(VK_FUNCTION_CMD_DRAW_INDIRECT_BYTE_COUNT_EXT_MWN, commandBuffer, instanceCount, firstInstance, counterBuffer, counterBufferOffset, counterOffset, vertexStride); +} +void vkCmdSetExclusiveScissorNV(VkCommandBuffer commandBuffer, uint32_t firstExclusiveScissor, uint32_t exclusiveScissorCount, const VkRect2D* pExclusiveScissors) +{ + g_dispatchTable.CmdSetExclusiveScissorNV(commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); + recordVoidFunction(VK_FUNCTION_CMD_SET_EXCLUSIVE_SCISSOR_NV_MWN, commandBuffer, firstExclusiveScissor, exclusiveScissorCount, pExclusiveScissors); +} +void vkCmdBindShadingRateImageNV(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) +{ + g_dispatchTable.CmdBindShadingRateImageNV(commandBuffer, imageView, imageLayout); + recordVoidFunction(VK_FUNCTION_CMD_BIND_SHADING_RATE_IMAGE_NV_MWN, commandBuffer, imageView, imageLayout); +} +void vkCmdSetViewportShadingRatePaletteNV(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkShadingRatePaletteNV* pShadingRatePalettes) +{ + g_dispatchTable.CmdSetViewportShadingRatePaletteNV(commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); + recordVoidFunction(VK_FUNCTION_CMD_SET_VIEWPORT_SHADING_RATE_PALETTE_NV_MWN, commandBuffer, firstViewport, viewportCount, pShadingRatePalettes); +} +void vkCmdSetCoarseSampleOrderNV(VkCommandBuffer commandBuffer, VkCoarseSampleOrderTypeNV sampleOrderType, uint32_t customSampleOrderCount, const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) +{ + g_dispatchTable.CmdSetCoarseSampleOrderNV(commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); + recordVoidFunction(VK_FUNCTION_CMD_SET_COARSE_SAMPLE_ORDER_NV_MWN, commandBuffer, sampleOrderType, customSampleOrderCount, pCustomSampleOrders); +} +void vkCmdDrawMeshTasksNV(VkCommandBuffer commandBuffer, uint32_t taskCount, uint32_t firstTask) +{ + g_dispatchTable.CmdDrawMeshTasksNV(commandBuffer, taskCount, firstTask); + recordVoidFunction(VK_FUNCTION_CMD_DRAW_MESH_TASKS_NV_MWN, commandBuffer, taskCount, firstTask); +} +void vkCmdDrawMeshTasksIndirectNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) +{ + g_dispatchTable.CmdDrawMeshTasksIndirectNV(commandBuffer, buffer, offset, drawCount, stride); + recordVoidFunction(VK_FUNCTION_CMD_DRAW_MESH_TASKS_INDIRECT_NV_MWN, commandBuffer, buffer, offset, drawCount, stride); +} +void vkCmdDrawMeshTasksIndirectCountNV(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, uint32_t stride) +{ + g_dispatchTable.CmdDrawMeshTasksIndirectCountNV(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); + recordVoidFunction(VK_FUNCTION_CMD_DRAW_MESH_TASKS_INDIRECT_COUNT_NV_MWN, commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); +} +VkResult vkCompileDeferredNV(VkDevice device, VkPipeline pipeline, uint32_t shader) +{ + auto result = g_dispatchTable.CompileDeferredNV(device, pipeline, shader); + recordFunction(VK_FUNCTION_COMPILE_DEFERRED_NV_MWN, result, device, pipeline, shader); + return result; +} +VkResult vkCreateAccelerationStructureNV(VkDevice device, const VkAccelerationStructureCreateInfoNV* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureNV* pAccelerationStructure) +{ + auto result = g_dispatchTable.CreateAccelerationStructureNV(device, pCreateInfo, pAllocator, pAccelerationStructure); + recordFunction(VK_FUNCTION_CREATE_ACCELERATION_STRUCTURE_NV_MWN, result, device, pCreateInfo, pAllocator, pAccelerationStructure); + return result; +} +void vkCmdBindInvocationMaskHUAWEI(VkCommandBuffer commandBuffer, VkImageView imageView, VkImageLayout imageLayout) +{ + g_dispatchTable.CmdBindInvocationMaskHUAWEI(commandBuffer, imageView, imageLayout); + recordVoidFunction(VK_FUNCTION_CMD_BIND_INVOCATION_MASK_HUAWEI_MWN, commandBuffer, imageView, imageLayout); +} +void vkDestroyAccelerationStructureKHR(VkDevice device, VkAccelerationStructureKHR accelerationStructure, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyAccelerationStructureKHR(device, accelerationStructure, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_ACCELERATION_STRUCTURE_KHR_MWN, device, accelerationStructure, pAllocator); +} +void vkDestroyAccelerationStructureNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyAccelerationStructureNV(device, accelerationStructure, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_ACCELERATION_STRUCTURE_NV_MWN, device, accelerationStructure, pAllocator); +} +void vkGetAccelerationStructureMemoryRequirementsNV(VkDevice device, const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements) +{ + g_dispatchTable.GetAccelerationStructureMemoryRequirementsNV(device, pInfo, pMemoryRequirements); + recordVoidFunction(VK_FUNCTION_GET_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_NV_MWN, device, pInfo, pMemoryRequirements); +} +VkResult vkBindAccelerationStructureMemoryNV(VkDevice device, uint32_t bindInfoCount, const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) +{ + auto result = g_dispatchTable.BindAccelerationStructureMemoryNV(device, bindInfoCount, pBindInfos); + recordFunction(VK_FUNCTION_BIND_ACCELERATION_STRUCTURE_MEMORY_NV_MWN, result, device, bindInfoCount, pBindInfos); + return result; +} +void vkCmdCopyAccelerationStructureNV(VkCommandBuffer commandBuffer, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkCopyAccelerationStructureModeKHR mode) +{ + g_dispatchTable.CmdCopyAccelerationStructureNV(commandBuffer, dst, src, mode); + recordVoidFunction(VK_FUNCTION_CMD_COPY_ACCELERATION_STRUCTURE_NV_MWN, commandBuffer, dst, src, mode); +} +void vkCmdCopyAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureInfoKHR* pInfo) +{ + g_dispatchTable.CmdCopyAccelerationStructureKHR(commandBuffer, pInfo); + recordVoidFunction(VK_FUNCTION_CMD_COPY_ACCELERATION_STRUCTURE_KHR_MWN, commandBuffer, pInfo); +} +VkResult vkCopyAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureInfoKHR* pInfo) +{ + auto result = g_dispatchTable.CopyAccelerationStructureKHR(device, deferredOperation, pInfo); + recordFunction(VK_FUNCTION_COPY_ACCELERATION_STRUCTURE_KHR_MWN, result, device, deferredOperation, pInfo); + return result; +} +void vkCmdCopyAccelerationStructureToMemoryKHR(VkCommandBuffer commandBuffer, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) +{ + g_dispatchTable.CmdCopyAccelerationStructureToMemoryKHR(commandBuffer, pInfo); + recordVoidFunction(VK_FUNCTION_CMD_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_KHR_MWN, commandBuffer, pInfo); +} +VkResult vkCopyAccelerationStructureToMemoryKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) +{ + auto result = g_dispatchTable.CopyAccelerationStructureToMemoryKHR(device, deferredOperation, pInfo); + recordFunction(VK_FUNCTION_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_KHR_MWN, result, device, deferredOperation, pInfo); + return result; +} +void vkCmdCopyMemoryToAccelerationStructureKHR(VkCommandBuffer commandBuffer, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) +{ + g_dispatchTable.CmdCopyMemoryToAccelerationStructureKHR(commandBuffer, pInfo); + recordVoidFunction(VK_FUNCTION_CMD_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_KHR_MWN, commandBuffer, pInfo); +} +VkResult vkCopyMemoryToAccelerationStructureKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) +{ + auto result = g_dispatchTable.CopyMemoryToAccelerationStructureKHR(device, deferredOperation, pInfo); + recordFunction(VK_FUNCTION_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_KHR_MWN, result, device, deferredOperation, pInfo); + return result; +} +void vkCmdWriteAccelerationStructuresPropertiesKHR(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) +{ + g_dispatchTable.CmdWriteAccelerationStructuresPropertiesKHR(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); + recordVoidFunction(VK_FUNCTION_CMD_WRITE_ACCELERATION_STRUCTURES_PROPERTIES_KHR_MWN, commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); +} +void vkCmdWriteAccelerationStructuresPropertiesNV(VkCommandBuffer commandBuffer, uint32_t accelerationStructureCount, const VkAccelerationStructureNV* pAccelerationStructures, VkQueryType queryType, VkQueryPool queryPool, uint32_t firstQuery) +{ + g_dispatchTable.CmdWriteAccelerationStructuresPropertiesNV(commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); + recordVoidFunction(VK_FUNCTION_CMD_WRITE_ACCELERATION_STRUCTURES_PROPERTIES_NV_MWN, commandBuffer, accelerationStructureCount, pAccelerationStructures, queryType, queryPool, firstQuery); +} +void vkCmdBuildAccelerationStructureNV(VkCommandBuffer commandBuffer, const VkAccelerationStructureInfoNV* pInfo, VkBuffer instanceData, VkDeviceSize instanceOffset, VkBool32 update, VkAccelerationStructureNV dst, VkAccelerationStructureNV src, VkBuffer scratch, VkDeviceSize scratchOffset) +{ + g_dispatchTable.CmdBuildAccelerationStructureNV(commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); + recordVoidFunction(VK_FUNCTION_CMD_BUILD_ACCELERATION_STRUCTURE_NV_MWN, commandBuffer, pInfo, instanceData, instanceOffset, update, dst, src, scratch, scratchOffset); +} +VkResult vkWriteAccelerationStructuresPropertiesKHR(VkDevice device, uint32_t accelerationStructureCount, const VkAccelerationStructureKHR* pAccelerationStructures, VkQueryType queryType, size_t dataSize, void* pData, size_t stride) +{ + auto result = g_dispatchTable.WriteAccelerationStructuresPropertiesKHR(device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride); + recordFunction(VK_FUNCTION_WRITE_ACCELERATION_STRUCTURES_PROPERTIES_KHR_MWN, result, device, accelerationStructureCount, pAccelerationStructures, queryType, dataSize, pData, stride); + return result; +} +void vkCmdTraceRaysKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, uint32_t width, uint32_t height, uint32_t depth) +{ + g_dispatchTable.CmdTraceRaysKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth); + recordVoidFunction(VK_FUNCTION_CMD_TRACE_RAYS_KHR_MWN, commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, width, height, depth); +} +void vkCmdTraceRaysNV(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) +{ + g_dispatchTable.CmdTraceRaysNV(commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); + recordVoidFunction(VK_FUNCTION_CMD_TRACE_RAYS_NV_MWN, commandBuffer, raygenShaderBindingTableBuffer, raygenShaderBindingOffset, missShaderBindingTableBuffer, missShaderBindingOffset, missShaderBindingStride, hitShaderBindingTableBuffer, hitShaderBindingOffset, hitShaderBindingStride, callableShaderBindingTableBuffer, callableShaderBindingOffset, callableShaderBindingStride, width, height, depth); +} +VkResult vkGetRayTracingShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) +{ + auto result = g_dispatchTable.GetRayTracingShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData); + recordFunction(VK_FUNCTION_GET_RAY_TRACING_SHADER_GROUP_HANDLES_KHR_MWN, result, device, pipeline, firstGroup, groupCount, dataSize, pData); + return result; +} +VkResult vkGetRayTracingCaptureReplayShaderGroupHandlesKHR(VkDevice device, VkPipeline pipeline, uint32_t firstGroup, uint32_t groupCount, size_t dataSize, void* pData) +{ + auto result = g_dispatchTable.GetRayTracingCaptureReplayShaderGroupHandlesKHR(device, pipeline, firstGroup, groupCount, dataSize, pData); + recordFunction(VK_FUNCTION_GET_RAY_TRACING_CAPTURE_REPLAY_SHADER_GROUP_HANDLES_KHR_MWN, result, device, pipeline, firstGroup, groupCount, dataSize, pData); + return result; +} +VkResult vkGetAccelerationStructureHandleNV(VkDevice device, VkAccelerationStructureNV accelerationStructure, size_t dataSize, void* pData) +{ + auto result = g_dispatchTable.GetAccelerationStructureHandleNV(device, accelerationStructure, dataSize, pData); + recordFunction(VK_FUNCTION_GET_ACCELERATION_STRUCTURE_HANDLE_NV_MWN, result, device, accelerationStructure, dataSize, pData); + return result; +} +VkResult vkCreateRayTracingPipelinesNV(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoNV* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + auto result = g_dispatchTable.CreateRayTracingPipelinesNV(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + recordFunction(VK_FUNCTION_CREATE_RAY_TRACING_PIPELINES_NV_MWN, result, device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + return result; +} +VkResult vkCreateRayTracingPipelinesKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) +{ + auto result = g_dispatchTable.CreateRayTracingPipelinesKHR(device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + recordFunction(VK_FUNCTION_CREATE_RAY_TRACING_PIPELINES_KHR_MWN, result, device, deferredOperation, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); + return result; +} +void vkCmdTraceRaysIndirectKHR(VkCommandBuffer commandBuffer, const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, VkDeviceAddress indirectDeviceAddress) +{ + g_dispatchTable.CmdTraceRaysIndirectKHR(commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress); + recordVoidFunction(VK_FUNCTION_CMD_TRACE_RAYS_INDIRECT_KHR_MWN, commandBuffer, pRaygenShaderBindingTable, pMissShaderBindingTable, pHitShaderBindingTable, pCallableShaderBindingTable, indirectDeviceAddress); +} +void vkCmdTraceRaysIndirect2KHR(VkCommandBuffer commandBuffer, VkDeviceAddress indirectDeviceAddress) +{ + g_dispatchTable.CmdTraceRaysIndirect2KHR(commandBuffer, indirectDeviceAddress); + recordVoidFunction(VK_FUNCTION_CMD_TRACE_RAYS_INDIRECT2_KHR_MWN, commandBuffer, indirectDeviceAddress); +} +void vkGetDeviceAccelerationStructureCompatibilityKHR(VkDevice device, const VkAccelerationStructureVersionInfoKHR* pVersionInfo, VkAccelerationStructureCompatibilityKHR* pCompatibility) +{ + g_dispatchTable.GetDeviceAccelerationStructureCompatibilityKHR(device, pVersionInfo, pCompatibility); + recordVoidFunction(VK_FUNCTION_GET_DEVICE_ACCELERATION_STRUCTURE_COMPATIBILITY_KHR_MWN, device, pVersionInfo, pCompatibility); +} +VkDeviceSize vkGetRayTracingShaderGroupStackSizeKHR(VkDevice device, VkPipeline pipeline, uint32_t group, VkShaderGroupShaderKHR groupShader) +{ + auto result = g_dispatchTable.GetRayTracingShaderGroupStackSizeKHR(device, pipeline, group, groupShader); + recordFunction(VK_FUNCTION_GET_RAY_TRACING_SHADER_GROUP_STACK_SIZE_KHR_MWN, result, device, pipeline, group, groupShader); + return result; +} +void vkCmdSetRayTracingPipelineStackSizeKHR(VkCommandBuffer commandBuffer, uint32_t pipelineStackSize) +{ + g_dispatchTable.CmdSetRayTracingPipelineStackSizeKHR(commandBuffer, pipelineStackSize); + recordVoidFunction(VK_FUNCTION_CMD_SET_RAY_TRACING_PIPELINE_STACK_SIZE_KHR_MWN, commandBuffer, pipelineStackSize); +} +uint32_t vkGetImageViewHandleNVX(VkDevice device, const VkImageViewHandleInfoNVX* pInfo) +{ + auto result = g_dispatchTable.GetImageViewHandleNVX(device, pInfo); + recordFunction(VK_FUNCTION_GET_IMAGE_VIEW_HANDLE_NVX_MWN, result, device, pInfo); + return result; +} +VkResult vkGetImageViewAddressNVX(VkDevice device, VkImageView imageView, VkImageViewAddressPropertiesNVX* pProperties) +{ + auto result = g_dispatchTable.GetImageViewAddressNVX(device, imageView, pProperties); + recordFunction(VK_FUNCTION_GET_IMAGE_VIEW_ADDRESS_NVX_MWN, result, device, imageView, pProperties); + return result; +} +VkResult vkAcquireProfilingLockKHR(VkDevice device, const VkAcquireProfilingLockInfoKHR* pInfo) +{ + auto result = g_dispatchTable.AcquireProfilingLockKHR(device, pInfo); + recordFunction(VK_FUNCTION_ACQUIRE_PROFILING_LOCK_KHR_MWN, result, device, pInfo); + return result; +} +void vkReleaseProfilingLockKHR(VkDevice device) +{ + g_dispatchTable.ReleaseProfilingLockKHR(device); + recordVoidFunction(VK_FUNCTION_RELEASE_PROFILING_LOCK_KHR_MWN, device); +} +VkResult vkGetImageDrmFormatModifierPropertiesEXT(VkDevice device, VkImage image, VkImageDrmFormatModifierPropertiesEXT* pProperties) +{ + auto result = g_dispatchTable.GetImageDrmFormatModifierPropertiesEXT(device, image, pProperties); + recordFunction(VK_FUNCTION_GET_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT_MWN, result, device, image, pProperties); + return result; +} +uint64_t vkGetBufferOpaqueCaptureAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + auto result = g_dispatchTable.GetBufferOpaqueCaptureAddress(device, pInfo); + recordFunction(VK_FUNCTION_GET_BUFFER_OPAQUE_CAPTURE_ADDRESS_MWN, result, device, pInfo); + return result; +} +VkDeviceAddress vkGetBufferDeviceAddress(VkDevice device, const VkBufferDeviceAddressInfo* pInfo) +{ + auto result = g_dispatchTable.GetBufferDeviceAddress(device, pInfo); + recordFunction(VK_FUNCTION_GET_BUFFER_DEVICE_ADDRESS_MWN, result, device, pInfo); + return result; +} +VkResult vkInitializePerformanceApiINTEL(VkDevice device, const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) +{ + auto result = g_dispatchTable.InitializePerformanceApiINTEL(device, pInitializeInfo); + recordFunction(VK_FUNCTION_INITIALIZE_PERFORMANCE_API_INTEL_MWN, result, device, pInitializeInfo); + return result; +} +void vkUninitializePerformanceApiINTEL(VkDevice device) +{ + g_dispatchTable.UninitializePerformanceApiINTEL(device); + recordVoidFunction(VK_FUNCTION_UNINITIALIZE_PERFORMANCE_API_INTEL_MWN, device); +} +VkResult vkCmdSetPerformanceMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceMarkerInfoINTEL* pMarkerInfo) +{ + auto result = g_dispatchTable.CmdSetPerformanceMarkerINTEL(commandBuffer, pMarkerInfo); + recordFunction(VK_FUNCTION_CMD_SET_PERFORMANCE_MARKER_INTEL_MWN, result, commandBuffer, pMarkerInfo); + return result; +} +VkResult vkCmdSetPerformanceStreamMarkerINTEL(VkCommandBuffer commandBuffer, const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) +{ + auto result = g_dispatchTable.CmdSetPerformanceStreamMarkerINTEL(commandBuffer, pMarkerInfo); + recordFunction(VK_FUNCTION_CMD_SET_PERFORMANCE_STREAM_MARKER_INTEL_MWN, result, commandBuffer, pMarkerInfo); + return result; +} +VkResult vkCmdSetPerformanceOverrideINTEL(VkCommandBuffer commandBuffer, const VkPerformanceOverrideInfoINTEL* pOverrideInfo) +{ + auto result = g_dispatchTable.CmdSetPerformanceOverrideINTEL(commandBuffer, pOverrideInfo); + recordFunction(VK_FUNCTION_CMD_SET_PERFORMANCE_OVERRIDE_INTEL_MWN, result, commandBuffer, pOverrideInfo); + return result; +} +VkResult vkAcquirePerformanceConfigurationINTEL(VkDevice device, const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, VkPerformanceConfigurationINTEL* pConfiguration) +{ + auto result = g_dispatchTable.AcquirePerformanceConfigurationINTEL(device, pAcquireInfo, pConfiguration); + recordFunction(VK_FUNCTION_ACQUIRE_PERFORMANCE_CONFIGURATION_INTEL_MWN, result, device, pAcquireInfo, pConfiguration); + return result; +} +VkResult vkReleasePerformanceConfigurationINTEL(VkDevice device, VkPerformanceConfigurationINTEL configuration) +{ + auto result = g_dispatchTable.ReleasePerformanceConfigurationINTEL(device, configuration); + recordFunction(VK_FUNCTION_RELEASE_PERFORMANCE_CONFIGURATION_INTEL_MWN, result, device, configuration); + return result; +} +VkResult vkQueueSetPerformanceConfigurationINTEL(VkQueue queue, VkPerformanceConfigurationINTEL configuration) +{ + auto result = g_dispatchTable.QueueSetPerformanceConfigurationINTEL(queue, configuration); + recordFunction(VK_FUNCTION_QUEUE_SET_PERFORMANCE_CONFIGURATION_INTEL_MWN, result, queue, configuration); + return result; +} +VkResult vkGetPerformanceParameterINTEL(VkDevice device, VkPerformanceParameterTypeINTEL parameter, VkPerformanceValueINTEL* pValue) +{ + auto result = g_dispatchTable.GetPerformanceParameterINTEL(device, parameter, pValue); + recordFunction(VK_FUNCTION_GET_PERFORMANCE_PARAMETER_INTEL_MWN, result, device, parameter, pValue); + return result; +} +uint64_t vkGetDeviceMemoryOpaqueCaptureAddress(VkDevice device, const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ + auto result = g_dispatchTable.GetDeviceMemoryOpaqueCaptureAddress(device, pInfo); + recordFunction(VK_FUNCTION_GET_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_MWN, result, device, pInfo); + return result; +} +VkResult vkGetPipelineExecutablePropertiesKHR(VkDevice device, const VkPipelineInfoKHR* pPipelineInfo, uint32_t* pExecutableCount, VkPipelineExecutablePropertiesKHR* pProperties) +{ + auto result = g_dispatchTable.GetPipelineExecutablePropertiesKHR(device, pPipelineInfo, pExecutableCount, pProperties); + recordFunction(VK_FUNCTION_GET_PIPELINE_EXECUTABLE_PROPERTIES_KHR_MWN, result, device, pPipelineInfo, pExecutableCount, pProperties); + return result; +} +VkResult vkGetPipelineExecutableStatisticsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pStatisticCount, VkPipelineExecutableStatisticKHR* pStatistics) +{ + auto result = g_dispatchTable.GetPipelineExecutableStatisticsKHR(device, pExecutableInfo, pStatisticCount, pStatistics); + recordFunction(VK_FUNCTION_GET_PIPELINE_EXECUTABLE_STATISTICS_KHR_MWN, result, device, pExecutableInfo, pStatisticCount, pStatistics); + return result; +} +VkResult vkGetPipelineExecutableInternalRepresentationsKHR(VkDevice device, const VkPipelineExecutableInfoKHR* pExecutableInfo, uint32_t* pInternalRepresentationCount, VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) +{ + auto result = g_dispatchTable.GetPipelineExecutableInternalRepresentationsKHR(device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); + recordFunction(VK_FUNCTION_GET_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATIONS_KHR_MWN, result, device, pExecutableInfo, pInternalRepresentationCount, pInternalRepresentations); + return result; +} +void vkCmdSetLineStippleEXT(VkCommandBuffer commandBuffer, uint32_t lineStippleFactor, uint16_t lineStipplePattern) +{ + g_dispatchTable.CmdSetLineStippleEXT(commandBuffer, lineStippleFactor, lineStipplePattern); + recordVoidFunction(VK_FUNCTION_CMD_SET_LINE_STIPPLE_EXT_MWN, commandBuffer, lineStippleFactor, lineStipplePattern); +} +VkResult vkCreateAccelerationStructureKHR(VkDevice device, const VkAccelerationStructureCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkAccelerationStructureKHR* pAccelerationStructure) +{ + auto result = g_dispatchTable.CreateAccelerationStructureKHR(device, pCreateInfo, pAllocator, pAccelerationStructure); + recordFunction(VK_FUNCTION_CREATE_ACCELERATION_STRUCTURE_KHR_MWN, result, device, pCreateInfo, pAllocator, pAccelerationStructure); + return result; +} +void vkCmdBuildAccelerationStructuresKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) +{ + g_dispatchTable.CmdBuildAccelerationStructuresKHR(commandBuffer, infoCount, pInfos, ppBuildRangeInfos); + recordVoidFunction(VK_FUNCTION_CMD_BUILD_ACCELERATION_STRUCTURES_KHR_MWN, commandBuffer, infoCount, pInfos, ppBuildRangeInfos); +} +void vkCmdBuildAccelerationStructuresIndirectKHR(VkCommandBuffer commandBuffer, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkDeviceAddress* pIndirectDeviceAddresses, const uint32_t* pIndirectStrides, const uint32_t* const* ppMaxPrimitiveCounts) +{ + g_dispatchTable.CmdBuildAccelerationStructuresIndirectKHR(commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); + recordVoidFunction(VK_FUNCTION_CMD_BUILD_ACCELERATION_STRUCTURES_INDIRECT_KHR_MWN, commandBuffer, infoCount, pInfos, pIndirectDeviceAddresses, pIndirectStrides, ppMaxPrimitiveCounts); +} +VkResult vkBuildAccelerationStructuresKHR(VkDevice device, VkDeferredOperationKHR deferredOperation, uint32_t infoCount, const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) +{ + auto result = g_dispatchTable.BuildAccelerationStructuresKHR(device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos); + recordFunction(VK_FUNCTION_BUILD_ACCELERATION_STRUCTURES_KHR_MWN, result, device, deferredOperation, infoCount, pInfos, ppBuildRangeInfos); + return result; +} +VkDeviceAddress vkGetAccelerationStructureDeviceAddressKHR(VkDevice device, const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) +{ + auto result = g_dispatchTable.GetAccelerationStructureDeviceAddressKHR(device, pInfo); + recordFunction(VK_FUNCTION_GET_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_KHR_MWN, result, device, pInfo); + return result; +} +VkResult vkCreateDeferredOperationKHR(VkDevice device, const VkAllocationCallbacks* pAllocator, VkDeferredOperationKHR* pDeferredOperation) +{ + auto result = g_dispatchTable.CreateDeferredOperationKHR(device, pAllocator, pDeferredOperation); + recordFunction(VK_FUNCTION_CREATE_DEFERRED_OPERATION_KHR_MWN, result, device, pAllocator, pDeferredOperation); + return result; +} +void vkDestroyDeferredOperationKHR(VkDevice device, VkDeferredOperationKHR operation, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyDeferredOperationKHR(device, operation, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_DEFERRED_OPERATION_KHR_MWN, device, operation, pAllocator); +} +uint32_t vkGetDeferredOperationMaxConcurrencyKHR(VkDevice device, VkDeferredOperationKHR operation) +{ + auto result = g_dispatchTable.GetDeferredOperationMaxConcurrencyKHR(device, operation); + recordFunction(VK_FUNCTION_GET_DEFERRED_OPERATION_MAX_CONCURRENCY_KHR_MWN, result, device, operation); + return result; +} +VkResult vkGetDeferredOperationResultKHR(VkDevice device, VkDeferredOperationKHR operation) +{ + auto result = g_dispatchTable.GetDeferredOperationResultKHR(device, operation); + recordFunction(VK_FUNCTION_GET_DEFERRED_OPERATION_RESULT_KHR_MWN, result, device, operation); + return result; +} +VkResult vkDeferredOperationJoinKHR(VkDevice device, VkDeferredOperationKHR operation) +{ + auto result = g_dispatchTable.DeferredOperationJoinKHR(device, operation); + recordFunction(VK_FUNCTION_DEFERRED_OPERATION_JOIN_KHR_MWN, result, device, operation); + return result; +} +void vkCmdSetCullMode(VkCommandBuffer commandBuffer, VkCullModeFlags cullMode) +{ + g_dispatchTable.CmdSetCullMode(commandBuffer, cullMode); + recordVoidFunction(VK_FUNCTION_CMD_SET_CULL_MODE_MWN, commandBuffer, cullMode); +} +void vkCmdSetFrontFace(VkCommandBuffer commandBuffer, VkFrontFace frontFace) +{ + g_dispatchTable.CmdSetFrontFace(commandBuffer, frontFace); + recordVoidFunction(VK_FUNCTION_CMD_SET_FRONT_FACE_MWN, commandBuffer, frontFace); +} +void vkCmdSetPrimitiveTopology(VkCommandBuffer commandBuffer, VkPrimitiveTopology primitiveTopology) +{ + g_dispatchTable.CmdSetPrimitiveTopology(commandBuffer, primitiveTopology); + recordVoidFunction(VK_FUNCTION_CMD_SET_PRIMITIVE_TOPOLOGY_MWN, commandBuffer, primitiveTopology); +} +void vkCmdSetViewportWithCount(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) +{ + g_dispatchTable.CmdSetViewportWithCount(commandBuffer, viewportCount, pViewports); + recordVoidFunction(VK_FUNCTION_CMD_SET_VIEWPORT_WITH_COUNT_MWN, commandBuffer, viewportCount, pViewports); +} +void vkCmdSetScissorWithCount(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) +{ + g_dispatchTable.CmdSetScissorWithCount(commandBuffer, scissorCount, pScissors); + recordVoidFunction(VK_FUNCTION_CMD_SET_SCISSOR_WITH_COUNT_MWN, commandBuffer, scissorCount, pScissors); +} +void vkCmdBindVertexBuffers2(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets, const VkDeviceSize* pSizes, const VkDeviceSize* pStrides) +{ + g_dispatchTable.CmdBindVertexBuffers2(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); + recordVoidFunction(VK_FUNCTION_CMD_BIND_VERTEX_BUFFERS2_MWN, commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets, pSizes, pStrides); +} +void vkCmdSetDepthTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthTestEnable) +{ + g_dispatchTable.CmdSetDepthTestEnable(commandBuffer, depthTestEnable); + recordVoidFunction(VK_FUNCTION_CMD_SET_DEPTH_TEST_ENABLE_MWN, commandBuffer, depthTestEnable); +} +void vkCmdSetDepthWriteEnable(VkCommandBuffer commandBuffer, VkBool32 depthWriteEnable) +{ + g_dispatchTable.CmdSetDepthWriteEnable(commandBuffer, depthWriteEnable); + recordVoidFunction(VK_FUNCTION_CMD_SET_DEPTH_WRITE_ENABLE_MWN, commandBuffer, depthWriteEnable); +} +void vkCmdSetDepthCompareOp(VkCommandBuffer commandBuffer, VkCompareOp depthCompareOp) +{ + g_dispatchTable.CmdSetDepthCompareOp(commandBuffer, depthCompareOp); + recordVoidFunction(VK_FUNCTION_CMD_SET_DEPTH_COMPARE_OP_MWN, commandBuffer, depthCompareOp); +} +void vkCmdSetDepthBoundsTestEnable(VkCommandBuffer commandBuffer, VkBool32 depthBoundsTestEnable) +{ + g_dispatchTable.CmdSetDepthBoundsTestEnable(commandBuffer, depthBoundsTestEnable); + recordVoidFunction(VK_FUNCTION_CMD_SET_DEPTH_BOUNDS_TEST_ENABLE_MWN, commandBuffer, depthBoundsTestEnable); +} +void vkCmdSetStencilTestEnable(VkCommandBuffer commandBuffer, VkBool32 stencilTestEnable) +{ + g_dispatchTable.CmdSetStencilTestEnable(commandBuffer, stencilTestEnable); + recordVoidFunction(VK_FUNCTION_CMD_SET_STENCIL_TEST_ENABLE_MWN, commandBuffer, stencilTestEnable); +} +void vkCmdSetStencilOp(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, VkStencilOp failOp, VkStencilOp passOp, VkStencilOp depthFailOp, VkCompareOp compareOp) +{ + g_dispatchTable.CmdSetStencilOp(commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); + recordVoidFunction(VK_FUNCTION_CMD_SET_STENCIL_OP_MWN, commandBuffer, faceMask, failOp, passOp, depthFailOp, compareOp); +} +void vkCmdSetPatchControlPointsEXT(VkCommandBuffer commandBuffer, uint32_t patchControlPoints) +{ + g_dispatchTable.CmdSetPatchControlPointsEXT(commandBuffer, patchControlPoints); + recordVoidFunction(VK_FUNCTION_CMD_SET_PATCH_CONTROL_POINTS_EXT_MWN, commandBuffer, patchControlPoints); +} +void vkCmdSetRasterizerDiscardEnable(VkCommandBuffer commandBuffer, VkBool32 rasterizerDiscardEnable) +{ + g_dispatchTable.CmdSetRasterizerDiscardEnable(commandBuffer, rasterizerDiscardEnable); + recordVoidFunction(VK_FUNCTION_CMD_SET_RASTERIZER_DISCARD_ENABLE_MWN, commandBuffer, rasterizerDiscardEnable); +} +void vkCmdSetDepthBiasEnable(VkCommandBuffer commandBuffer, VkBool32 depthBiasEnable) +{ + g_dispatchTable.CmdSetDepthBiasEnable(commandBuffer, depthBiasEnable); + recordVoidFunction(VK_FUNCTION_CMD_SET_DEPTH_BIAS_ENABLE_MWN, commandBuffer, depthBiasEnable); +} +void vkCmdSetLogicOpEXT(VkCommandBuffer commandBuffer, VkLogicOp logicOp) +{ + g_dispatchTable.CmdSetLogicOpEXT(commandBuffer, logicOp); + recordVoidFunction(VK_FUNCTION_CMD_SET_LOGIC_OP_EXT_MWN, commandBuffer, logicOp); +} +void vkCmdSetPrimitiveRestartEnable(VkCommandBuffer commandBuffer, VkBool32 primitiveRestartEnable) +{ + g_dispatchTable.CmdSetPrimitiveRestartEnable(commandBuffer, primitiveRestartEnable); + recordVoidFunction(VK_FUNCTION_CMD_SET_PRIMITIVE_RESTART_ENABLE_MWN, commandBuffer, primitiveRestartEnable); +} +VkResult vkCreatePrivateDataSlot(VkDevice device, const VkPrivateDataSlotCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPrivateDataSlot* pPrivateDataSlot) +{ + auto result = g_dispatchTable.CreatePrivateDataSlot(device, pCreateInfo, pAllocator, pPrivateDataSlot); + recordFunction(VK_FUNCTION_CREATE_PRIVATE_DATA_SLOT_MWN, result, device, pCreateInfo, pAllocator, pPrivateDataSlot); + return result; +} +void vkDestroyPrivateDataSlot(VkDevice device, VkPrivateDataSlot privateDataSlot, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyPrivateDataSlot(device, privateDataSlot, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_PRIVATE_DATA_SLOT_MWN, device, privateDataSlot, pAllocator); +} +VkResult vkSetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t data) +{ + auto result = g_dispatchTable.SetPrivateData(device, objectType, objectHandle, privateDataSlot, data); + recordFunction(VK_FUNCTION_SET_PRIVATE_DATA_MWN, result, device, objectType, objectHandle, privateDataSlot, data); + return result; +} +void vkGetPrivateData(VkDevice device, VkObjectType objectType, uint64_t objectHandle, VkPrivateDataSlot privateDataSlot, uint64_t* pData) +{ + g_dispatchTable.GetPrivateData(device, objectType, objectHandle, privateDataSlot, pData); + recordVoidFunction(VK_FUNCTION_GET_PRIVATE_DATA_MWN, device, objectType, objectHandle, privateDataSlot, pData); +} +void vkCmdCopyBuffer2(VkCommandBuffer commandBuffer, const VkCopyBufferInfo2* pCopyBufferInfo) +{ + g_dispatchTable.CmdCopyBuffer2(commandBuffer, pCopyBufferInfo); + recordVoidFunction(VK_FUNCTION_CMD_COPY_BUFFER2_MWN, commandBuffer, pCopyBufferInfo); +} +void vkCmdCopyImage2(VkCommandBuffer commandBuffer, const VkCopyImageInfo2* pCopyImageInfo) +{ + g_dispatchTable.CmdCopyImage2(commandBuffer, pCopyImageInfo); + recordVoidFunction(VK_FUNCTION_CMD_COPY_IMAGE2_MWN, commandBuffer, pCopyImageInfo); +} +void vkCmdBlitImage2(VkCommandBuffer commandBuffer, const VkBlitImageInfo2* pBlitImageInfo) +{ + g_dispatchTable.CmdBlitImage2(commandBuffer, pBlitImageInfo); + recordVoidFunction(VK_FUNCTION_CMD_BLIT_IMAGE2_MWN, commandBuffer, pBlitImageInfo); +} +void vkCmdCopyBufferToImage2(VkCommandBuffer commandBuffer, const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ + g_dispatchTable.CmdCopyBufferToImage2(commandBuffer, pCopyBufferToImageInfo); + recordVoidFunction(VK_FUNCTION_CMD_COPY_BUFFER_TO_IMAGE2_MWN, commandBuffer, pCopyBufferToImageInfo); +} +void vkCmdCopyImageToBuffer2(VkCommandBuffer commandBuffer, const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ + g_dispatchTable.CmdCopyImageToBuffer2(commandBuffer, pCopyImageToBufferInfo); + recordVoidFunction(VK_FUNCTION_CMD_COPY_IMAGE_TO_BUFFER2_MWN, commandBuffer, pCopyImageToBufferInfo); +} +void vkCmdResolveImage2(VkCommandBuffer commandBuffer, const VkResolveImageInfo2* pResolveImageInfo) +{ + g_dispatchTable.CmdResolveImage2(commandBuffer, pResolveImageInfo); + recordVoidFunction(VK_FUNCTION_CMD_RESOLVE_IMAGE2_MWN, commandBuffer, pResolveImageInfo); +} +void vkCmdSetFragmentShadingRateKHR(VkCommandBuffer commandBuffer, const VkExtent2D* pFragmentSize, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) +{ + g_dispatchTable.CmdSetFragmentShadingRateKHR(commandBuffer, pFragmentSize, combinerOps); + recordVoidFunction(VK_FUNCTION_CMD_SET_FRAGMENT_SHADING_RATE_KHR_MWN, commandBuffer, pFragmentSize, combinerOps); +} +void vkCmdSetFragmentShadingRateEnumNV(VkCommandBuffer commandBuffer, VkFragmentShadingRateNV shadingRate, const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) +{ + g_dispatchTable.CmdSetFragmentShadingRateEnumNV(commandBuffer, shadingRate, combinerOps); + recordVoidFunction(VK_FUNCTION_CMD_SET_FRAGMENT_SHADING_RATE_ENUM_NV_MWN, commandBuffer, shadingRate, combinerOps); +} +void vkGetAccelerationStructureBuildSizesKHR(VkDevice device, VkAccelerationStructureBuildTypeKHR buildType, const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, const uint32_t* pMaxPrimitiveCounts, VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) +{ + g_dispatchTable.GetAccelerationStructureBuildSizesKHR(device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo); + recordVoidFunction(VK_FUNCTION_GET_ACCELERATION_STRUCTURE_BUILD_SIZES_KHR_MWN, device, buildType, pBuildInfo, pMaxPrimitiveCounts, pSizeInfo); +} +void vkCmdSetVertexInputEXT(VkCommandBuffer commandBuffer, uint32_t vertexBindingDescriptionCount, const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, uint32_t vertexAttributeDescriptionCount, const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions) +{ + g_dispatchTable.CmdSetVertexInputEXT(commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); + recordVoidFunction(VK_FUNCTION_CMD_SET_VERTEX_INPUT_EXT_MWN, commandBuffer, vertexBindingDescriptionCount, pVertexBindingDescriptions, vertexAttributeDescriptionCount, pVertexAttributeDescriptions); +} +void vkCmdSetColorWriteEnableEXT(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkBool32* pColorWriteEnables) +{ + g_dispatchTable.CmdSetColorWriteEnableEXT(commandBuffer, attachmentCount, pColorWriteEnables); + recordVoidFunction(VK_FUNCTION_CMD_SET_COLOR_WRITE_ENABLE_EXT_MWN, commandBuffer, attachmentCount, pColorWriteEnables); +} +void vkCmdSetEvent2(VkCommandBuffer commandBuffer, VkEvent event, const VkDependencyInfo* pDependencyInfo) +{ + g_dispatchTable.CmdSetEvent2(commandBuffer, event, pDependencyInfo); + recordVoidFunction(VK_FUNCTION_CMD_SET_EVENT2_MWN, commandBuffer, event, pDependencyInfo); +} +void vkCmdResetEvent2(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags2 stageMask) +{ + g_dispatchTable.CmdResetEvent2(commandBuffer, event, stageMask); + recordVoidFunction(VK_FUNCTION_CMD_RESET_EVENT2_MWN, commandBuffer, event, stageMask); +} +void vkCmdWaitEvents2(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, const VkDependencyInfo* pDependencyInfos) +{ + g_dispatchTable.CmdWaitEvents2(commandBuffer, eventCount, pEvents, pDependencyInfos); + recordVoidFunction(VK_FUNCTION_CMD_WAIT_EVENTS2_MWN, commandBuffer, eventCount, pEvents, pDependencyInfos); +} +void vkCmdPipelineBarrier2(VkCommandBuffer commandBuffer, const VkDependencyInfo* pDependencyInfo) +{ + g_dispatchTable.CmdPipelineBarrier2(commandBuffer, pDependencyInfo); + recordVoidFunction(VK_FUNCTION_CMD_PIPELINE_BARRIER2_MWN, commandBuffer, pDependencyInfo); +} +VkResult vkQueueSubmit2(VkQueue queue, uint32_t submitCount, const VkSubmitInfo2* pSubmits, VkFence fence) +{ + auto result = g_dispatchTable.QueueSubmit2(queue, submitCount, pSubmits, fence); + recordFunction(VK_FUNCTION_QUEUE_SUBMIT2_MWN, result, queue, submitCount, pSubmits, fence); + return result; +} +void vkCmdWriteTimestamp2(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkQueryPool queryPool, uint32_t query) +{ + g_dispatchTable.CmdWriteTimestamp2(commandBuffer, stage, queryPool, query); + recordVoidFunction(VK_FUNCTION_CMD_WRITE_TIMESTAMP2_MWN, commandBuffer, stage, queryPool, query); +} +void vkCmdWriteBufferMarker2AMD(VkCommandBuffer commandBuffer, VkPipelineStageFlags2 stage, VkBuffer dstBuffer, VkDeviceSize dstOffset, uint32_t marker) +{ + g_dispatchTable.CmdWriteBufferMarker2AMD(commandBuffer, stage, dstBuffer, dstOffset, marker); + recordVoidFunction(VK_FUNCTION_CMD_WRITE_BUFFER_MARKER2_AMD_MWN, commandBuffer, stage, dstBuffer, dstOffset, marker); +} +void vkGetQueueCheckpointData2NV(VkQueue queue, uint32_t* pCheckpointDataCount, VkCheckpointData2NV* pCheckpointData) +{ + g_dispatchTable.GetQueueCheckpointData2NV(queue, pCheckpointDataCount, pCheckpointData); + recordVoidFunction(VK_FUNCTION_GET_QUEUE_CHECKPOINT_DATA2_NV_MWN, queue, pCheckpointDataCount, pCheckpointData); +} +VkResult vkCreateCuModuleNVX(VkDevice device, const VkCuModuleCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuModuleNVX* pModule) +{ + auto result = g_dispatchTable.CreateCuModuleNVX(device, pCreateInfo, pAllocator, pModule); + recordFunction(VK_FUNCTION_CREATE_CU_MODULE_NVX_MWN, result, device, pCreateInfo, pAllocator, pModule); + return result; +} +VkResult vkCreateCuFunctionNVX(VkDevice device, const VkCuFunctionCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCuFunctionNVX* pFunction) +{ + auto result = g_dispatchTable.CreateCuFunctionNVX(device, pCreateInfo, pAllocator, pFunction); + recordFunction(VK_FUNCTION_CREATE_CU_FUNCTION_NVX_MWN, result, device, pCreateInfo, pAllocator, pFunction); + return result; +} +void vkDestroyCuModuleNVX(VkDevice device, VkCuModuleNVX module, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyCuModuleNVX(device, module, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_CU_MODULE_NVX_MWN, device, module, pAllocator); +} +void vkDestroyCuFunctionNVX(VkDevice device, VkCuFunctionNVX function, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyCuFunctionNVX(device, function, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_CU_FUNCTION_NVX_MWN, device, function, pAllocator); +} +void vkCmdCuLaunchKernelNVX(VkCommandBuffer commandBuffer, const VkCuLaunchInfoNVX* pLaunchInfo) +{ + g_dispatchTable.CmdCuLaunchKernelNVX(commandBuffer, pLaunchInfo); + recordVoidFunction(VK_FUNCTION_CMD_CU_LAUNCH_KERNEL_NVX_MWN, commandBuffer, pLaunchInfo); +} +void vkSetDeviceMemoryPriorityEXT(VkDevice device, VkDeviceMemory memory, float priority) +{ + g_dispatchTable.SetDeviceMemoryPriorityEXT(device, memory, priority); + recordVoidFunction(VK_FUNCTION_SET_DEVICE_MEMORY_PRIORITY_EXT_MWN, device, memory, priority); +} +VkResult vkWaitForPresentKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t presentId, uint64_t timeout) +{ + auto result = g_dispatchTable.WaitForPresentKHR(device, swapchain, presentId, timeout); + recordFunction(VK_FUNCTION_WAIT_FOR_PRESENT_KHR_MWN, result, device, swapchain, presentId, timeout); + return result; +} +void vkCmdBeginRendering(VkCommandBuffer commandBuffer, const VkRenderingInfo* pRenderingInfo) +{ + g_dispatchTable.CmdBeginRendering(commandBuffer, pRenderingInfo); + recordVoidFunction(VK_FUNCTION_CMD_BEGIN_RENDERING_MWN, commandBuffer, pRenderingInfo); +} +void vkCmdEndRendering(VkCommandBuffer commandBuffer) +{ + g_dispatchTable.CmdEndRendering(commandBuffer); + recordVoidFunction(VK_FUNCTION_CMD_END_RENDERING_MWN, commandBuffer); +} +void vkGetDescriptorSetLayoutHostMappingInfoVALVE(VkDevice device, const VkDescriptorSetBindingReferenceVALVE* pBindingReference, VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) +{ + g_dispatchTable.GetDescriptorSetLayoutHostMappingInfoVALVE(device, pBindingReference, pHostMapping); + recordVoidFunction(VK_FUNCTION_GET_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE_MWN, device, pBindingReference, pHostMapping); +} +void vkGetDescriptorSetHostMappingVALVE(VkDevice device, VkDescriptorSet descriptorSet, void** ppData) +{ + g_dispatchTable.GetDescriptorSetHostMappingVALVE(device, descriptorSet, ppData); + recordVoidFunction(VK_FUNCTION_GET_DESCRIPTOR_SET_HOST_MAPPING_VALVE_MWN, device, descriptorSet, ppData); +} +void vkGetImageSubresourceLayout2EXT(VkDevice device, VkImage image, const VkImageSubresource2EXT* pSubresource, VkSubresourceLayout2EXT* pLayout) +{ + g_dispatchTable.GetImageSubresourceLayout2EXT(device, image, pSubresource, pLayout); + recordVoidFunction(VK_FUNCTION_GET_IMAGE_SUBRESOURCE_LAYOUT2_EXT_MWN, device, image, pSubresource, pLayout); +} +VkResult vkGetPipelinePropertiesEXT(VkDevice device, const VkPipelineInfoEXT* pPipelineInfo, VkBaseOutStructure* pPipelineProperties) +{ + auto result = g_dispatchTable.GetPipelinePropertiesEXT(device, pPipelineInfo, pPipelineProperties); + recordFunction(VK_FUNCTION_GET_PIPELINE_PROPERTIES_EXT_MWN, result, device, pPipelineInfo, pPipelineProperties); + return result; +} + +#if defined(VK_USE_PLATFORM_ANDROID_KHR) +VkResult vkGetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage) +{ + auto result = g_dispatchTable.GetSwapchainGrallocUsageANDROID(device, format, imageUsage, grallocUsage); + recordFunction(VK_FUNCTION_GET_SWAPCHAIN_GRALLOC_USAGE_ANDROID_MWN, result, device, format, imageUsage, grallocUsage); + return result; +} +VkResult vkGetSwapchainGrallocUsage2ANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage, uint64_t* grallocProducerUsage) +{ + auto result = g_dispatchTable.GetSwapchainGrallocUsage2ANDROID(device, format, imageUsage, swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage); + recordFunction(VK_FUNCTION_GET_SWAPCHAIN_GRALLOC_USAGE2_ANDROID_MWN, result, device, format, imageUsage, swapchainImageUsage, grallocConsumerUsage, grallocProducerUsage); + return result; +} +VkResult vkAcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence) +{ + auto result = g_dispatchTable.AcquireImageANDROID(device, image, nativeFenceFd, semaphore, fence); + recordFunction(VK_FUNCTION_ACQUIRE_IMAGE_ANDROID_MWN, result, device, image, nativeFenceFd, semaphore, fence); + return result; +} +VkResult vkQueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int* pNativeFenceFd) +{ + auto result = g_dispatchTable.QueueSignalReleaseImageANDROID(queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd); + recordFunction(VK_FUNCTION_QUEUE_SIGNAL_RELEASE_IMAGE_ANDROID_MWN, result, queue, waitSemaphoreCount, pWaitSemaphores, image, pNativeFenceFd); + return result; +} +VkResult vkGetAndroidHardwareBufferPropertiesANDROID(VkDevice device, const struct AHardwareBuffer* buffer, VkAndroidHardwareBufferPropertiesANDROID* pProperties) +{ + auto result = g_dispatchTable.GetAndroidHardwareBufferPropertiesANDROID(device, buffer, pProperties); + recordFunction(VK_FUNCTION_GET_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID_MWN, result, device, buffer, pProperties); + return result; +} +VkResult vkGetMemoryAndroidHardwareBufferANDROID(VkDevice device, const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, struct AHardwareBuffer** pBuffer) +{ + auto result = g_dispatchTable.GetMemoryAndroidHardwareBufferANDROID(device, pInfo, pBuffer); + recordFunction(VK_FUNCTION_GET_MEMORY_ANDROID_HARDWARE_BUFFER_ANDROID_MWN, result, device, pInfo, pBuffer); + return result; +} + +#endif // defined(VK_USE_PLATFORM_ANDROID_KHR) + +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) + +#endif // defined(VK_USE_PLATFORM_DIRECTFB_EXT) + +#if defined(VK_USE_PLATFORM_FUCHSIA) +VkResult vkGetMemoryZirconHandleFUCHSIA(VkDevice device, const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) +{ + auto result = g_dispatchTable.GetMemoryZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle); + recordFunction(VK_FUNCTION_GET_MEMORY_ZIRCON_HANDLE_FUCHSIA_MWN, result, device, pGetZirconHandleInfo, pZirconHandle); + return result; +} +VkResult vkGetMemoryZirconHandlePropertiesFUCHSIA(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, zx_handle_t zirconHandle, VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) +{ + auto result = g_dispatchTable.GetMemoryZirconHandlePropertiesFUCHSIA(device, handleType, zirconHandle, pMemoryZirconHandleProperties); + recordFunction(VK_FUNCTION_GET_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA_MWN, result, device, handleType, zirconHandle, pMemoryZirconHandleProperties); + return result; +} +VkResult vkGetSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, zx_handle_t* pZirconHandle) +{ + auto result = g_dispatchTable.GetSemaphoreZirconHandleFUCHSIA(device, pGetZirconHandleInfo, pZirconHandle); + recordFunction(VK_FUNCTION_GET_SEMAPHORE_ZIRCON_HANDLE_FUCHSIA_MWN, result, device, pGetZirconHandleInfo, pZirconHandle); + return result; +} +VkResult vkImportSemaphoreZirconHandleFUCHSIA(VkDevice device, const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) +{ + auto result = g_dispatchTable.ImportSemaphoreZirconHandleFUCHSIA(device, pImportSemaphoreZirconHandleInfo); + recordFunction(VK_FUNCTION_IMPORT_SEMAPHORE_ZIRCON_HANDLE_FUCHSIA_MWN, result, device, pImportSemaphoreZirconHandleInfo); + return result; +} +VkResult vkCreateBufferCollectionFUCHSIA(VkDevice device, const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferCollectionFUCHSIA* pCollection) +{ + auto result = g_dispatchTable.CreateBufferCollectionFUCHSIA(device, pCreateInfo, pAllocator, pCollection); + recordFunction(VK_FUNCTION_CREATE_BUFFER_COLLECTION_FUCHSIA_MWN, result, device, pCreateInfo, pAllocator, pCollection); + return result; +} +VkResult vkSetBufferCollectionBufferConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) +{ + auto result = g_dispatchTable.SetBufferCollectionBufferConstraintsFUCHSIA(device, collection, pBufferConstraintsInfo); + recordFunction(VK_FUNCTION_SET_BUFFER_COLLECTION_BUFFER_CONSTRAINTS_FUCHSIA_MWN, result, device, collection, pBufferConstraintsInfo); + return result; +} +VkResult vkSetBufferCollectionImageConstraintsFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) +{ + auto result = g_dispatchTable.SetBufferCollectionImageConstraintsFUCHSIA(device, collection, pImageConstraintsInfo); + recordFunction(VK_FUNCTION_SET_BUFFER_COLLECTION_IMAGE_CONSTRAINTS_FUCHSIA_MWN, result, device, collection, pImageConstraintsInfo); + return result; +} +void vkDestroyBufferCollectionFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyBufferCollectionFUCHSIA(device, collection, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_BUFFER_COLLECTION_FUCHSIA_MWN, device, collection, pAllocator); +} +VkResult vkGetBufferCollectionPropertiesFUCHSIA(VkDevice device, VkBufferCollectionFUCHSIA collection, VkBufferCollectionPropertiesFUCHSIA* pProperties) +{ + auto result = g_dispatchTable.GetBufferCollectionPropertiesFUCHSIA(device, collection, pProperties); + recordFunction(VK_FUNCTION_GET_BUFFER_COLLECTION_PROPERTIES_FUCHSIA_MWN, result, device, collection, pProperties); + return result; +} + +#endif // defined(VK_USE_PLATFORM_FUCHSIA) + +#if defined(VK_USE_PLATFORM_GGP) + +#endif // defined(VK_USE_PLATFORM_GGP) + +#if defined(VK_USE_PLATFORM_IOS_MVK) + +#endif // defined(VK_USE_PLATFORM_IOS_MVK) + +#if defined(VK_USE_PLATFORM_MACOS_MVK) + +#endif // defined(VK_USE_PLATFORM_MACOS_MVK) + +#if defined(VK_USE_PLATFORM_METAL_EXT) +void vkExportMetalObjectsEXT(VkDevice device, VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) +{ + g_dispatchTable.ExportMetalObjectsEXT(device, pMetalObjectsInfo); + recordVoidFunction(VK_FUNCTION_EXPORT_METAL_OBJECTS_EXT_MWN, device, pMetalObjectsInfo); +} + +#endif // defined(VK_USE_PLATFORM_METAL_EXT) + +#if defined(VK_ENABLE_BETA_EXTENSIONS) +VkResult vkCreateVideoSessionKHR(VkDevice device, const VkVideoSessionCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionKHR* pVideoSession) +{ + auto result = g_dispatchTable.CreateVideoSessionKHR(device, pCreateInfo, pAllocator, pVideoSession); + recordFunction(VK_FUNCTION_CREATE_VIDEO_SESSION_KHR_MWN, result, device, pCreateInfo, pAllocator, pVideoSession); + return result; +} +void vkDestroyVideoSessionKHR(VkDevice device, VkVideoSessionKHR videoSession, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyVideoSessionKHR(device, videoSession, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_VIDEO_SESSION_KHR_MWN, device, videoSession, pAllocator); +} +VkResult vkCreateVideoSessionParametersKHR(VkDevice device, const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkVideoSessionParametersKHR* pVideoSessionParameters) +{ + auto result = g_dispatchTable.CreateVideoSessionParametersKHR(device, pCreateInfo, pAllocator, pVideoSessionParameters); + recordFunction(VK_FUNCTION_CREATE_VIDEO_SESSION_PARAMETERS_KHR_MWN, result, device, pCreateInfo, pAllocator, pVideoSessionParameters); + return result; +} +VkResult vkUpdateVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) +{ + auto result = g_dispatchTable.UpdateVideoSessionParametersKHR(device, videoSessionParameters, pUpdateInfo); + recordFunction(VK_FUNCTION_UPDATE_VIDEO_SESSION_PARAMETERS_KHR_MWN, result, device, videoSessionParameters, pUpdateInfo); + return result; +} +void vkDestroyVideoSessionParametersKHR(VkDevice device, VkVideoSessionParametersKHR videoSessionParameters, const VkAllocationCallbacks* pAllocator) +{ + g_dispatchTable.DestroyVideoSessionParametersKHR(device, videoSessionParameters, pAllocator); + recordVoidFunction(VK_FUNCTION_DESTROY_VIDEO_SESSION_PARAMETERS_KHR_MWN, device, videoSessionParameters, pAllocator); +} +VkResult vkGetVideoSessionMemoryRequirementsKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t* pMemoryRequirementsCount, VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) +{ + auto result = g_dispatchTable.GetVideoSessionMemoryRequirementsKHR(device, videoSession, pMemoryRequirementsCount, pMemoryRequirements); + recordFunction(VK_FUNCTION_GET_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR_MWN, result, device, videoSession, pMemoryRequirementsCount, pMemoryRequirements); + return result; +} +VkResult vkBindVideoSessionMemoryKHR(VkDevice device, VkVideoSessionKHR videoSession, uint32_t bindSessionMemoryInfoCount, const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) +{ + auto result = g_dispatchTable.BindVideoSessionMemoryKHR(device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos); + recordFunction(VK_FUNCTION_BIND_VIDEO_SESSION_MEMORY_KHR_MWN, result, device, videoSession, bindSessionMemoryInfoCount, pBindSessionMemoryInfos); + return result; +} +void vkCmdDecodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoDecodeInfoKHR* pFrameInfo) +{ + g_dispatchTable.CmdDecodeVideoKHR(commandBuffer, pFrameInfo); + recordVoidFunction(VK_FUNCTION_CMD_DECODE_VIDEO_KHR_MWN, commandBuffer, pFrameInfo); +} +void vkCmdBeginVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoBeginCodingInfoKHR* pBeginInfo) +{ + g_dispatchTable.CmdBeginVideoCodingKHR(commandBuffer, pBeginInfo); + recordVoidFunction(VK_FUNCTION_CMD_BEGIN_VIDEO_CODING_KHR_MWN, commandBuffer, pBeginInfo); +} +void vkCmdControlVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoCodingControlInfoKHR* pCodingControlInfo) +{ + g_dispatchTable.CmdControlVideoCodingKHR(commandBuffer, pCodingControlInfo); + recordVoidFunction(VK_FUNCTION_CMD_CONTROL_VIDEO_CODING_KHR_MWN, commandBuffer, pCodingControlInfo); +} +void vkCmdEndVideoCodingKHR(VkCommandBuffer commandBuffer, const VkVideoEndCodingInfoKHR* pEndCodingInfo) +{ + g_dispatchTable.CmdEndVideoCodingKHR(commandBuffer, pEndCodingInfo); + recordVoidFunction(VK_FUNCTION_CMD_END_VIDEO_CODING_KHR_MWN, commandBuffer, pEndCodingInfo); +} +void vkCmdEncodeVideoKHR(VkCommandBuffer commandBuffer, const VkVideoEncodeInfoKHR* pEncodeInfo) +{ + g_dispatchTable.CmdEncodeVideoKHR(commandBuffer, pEncodeInfo); + recordVoidFunction(VK_FUNCTION_CMD_ENCODE_VIDEO_KHR_MWN, commandBuffer, pEncodeInfo); +} + +#endif // defined(VK_ENABLE_BETA_EXTENSIONS) + +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + +#endif // defined(VK_USE_PLATFORM_SCREEN_QNX) + +#if defined(VK_USE_PLATFORM_VI_NN) + +#endif // defined(VK_USE_PLATFORM_VI_NN) + +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + +#endif // defined(VK_USE_PLATFORM_WAYLAND_KHR) + +#if defined(VK_USE_PLATFORM_WIN32_KHR) +VkResult vkGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE* pHandle) +{ + auto result = g_dispatchTable.GetMemoryWin32HandleNV(device, memory, handleType, pHandle); + recordFunction(VK_FUNCTION_GET_MEMORY_WIN32_HANDLE_NV_MWN, result, device, memory, handleType, pHandle); + return result; +} +VkResult vkGetMemoryWin32HandleKHR(VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) +{ + auto result = g_dispatchTable.GetMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); + recordFunction(VK_FUNCTION_GET_MEMORY_WIN32_HANDLE_KHR_MWN, result, device, pGetWin32HandleInfo, pHandle); + return result; +} +VkResult vkGetMemoryWin32HandlePropertiesKHR(VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, HANDLE handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) +{ + auto result = g_dispatchTable.GetMemoryWin32HandlePropertiesKHR(device, handleType, handle, pMemoryWin32HandleProperties); + recordFunction(VK_FUNCTION_GET_MEMORY_WIN32_HANDLE_PROPERTIES_KHR_MWN, result, device, handleType, handle, pMemoryWin32HandleProperties); + return result; +} +VkResult vkGetSemaphoreWin32HandleKHR(VkDevice device, const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) +{ + auto result = g_dispatchTable.GetSemaphoreWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); + recordFunction(VK_FUNCTION_GET_SEMAPHORE_WIN32_HANDLE_KHR_MWN, result, device, pGetWin32HandleInfo, pHandle); + return result; +} +VkResult vkImportSemaphoreWin32HandleKHR(VkDevice device, const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) +{ + auto result = g_dispatchTable.ImportSemaphoreWin32HandleKHR(device, pImportSemaphoreWin32HandleInfo); + recordFunction(VK_FUNCTION_IMPORT_SEMAPHORE_WIN32_HANDLE_KHR_MWN, result, device, pImportSemaphoreWin32HandleInfo); + return result; +} +VkResult vkGetFenceWin32HandleKHR(VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, HANDLE* pHandle) +{ + auto result = g_dispatchTable.GetFenceWin32HandleKHR(device, pGetWin32HandleInfo, pHandle); + recordFunction(VK_FUNCTION_GET_FENCE_WIN32_HANDLE_KHR_MWN, result, device, pGetWin32HandleInfo, pHandle); + return result; +} +VkResult vkImportFenceWin32HandleKHR(VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) +{ + auto result = g_dispatchTable.ImportFenceWin32HandleKHR(device, pImportFenceWin32HandleInfo); + recordFunction(VK_FUNCTION_IMPORT_FENCE_WIN32_HANDLE_KHR_MWN, result, device, pImportFenceWin32HandleInfo); + return result; +} +VkResult vkAcquireFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) +{ + auto result = g_dispatchTable.AcquireFullScreenExclusiveModeEXT(device, swapchain); + recordFunction(VK_FUNCTION_ACQUIRE_FULL_SCREEN_EXCLUSIVE_MODE_EXT_MWN, result, device, swapchain); + return result; +} +VkResult vkReleaseFullScreenExclusiveModeEXT(VkDevice device, VkSwapchainKHR swapchain) +{ + auto result = g_dispatchTable.ReleaseFullScreenExclusiveModeEXT(device, swapchain); + recordFunction(VK_FUNCTION_RELEASE_FULL_SCREEN_EXCLUSIVE_MODE_EXT_MWN, result, device, swapchain); + return result; +} + +#endif // defined(VK_USE_PLATFORM_WIN32_KHR) + +#if defined(VK_USE_PLATFORM_XCB_KHR) + +#endif // defined(VK_USE_PLATFORM_XCB_KHR) + +#if defined(VK_USE_PLATFORM_XLIB_KHR) + +#endif // defined(VK_USE_PLATFORM_XLIB_KHR) + +#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) +#endif // defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) +PFN_vkVoidFunction getWrappedFunctionPtr(const char* pName) +{ + + if (std::strcmp(pName, "vkGetDeviceQueue") == 0) { + return reinterpret_cast(&vkGetDeviceQueue); + } else + if (std::strcmp(pName, "vkQueueSubmit") == 0) { + return reinterpret_cast(&vkQueueSubmit); + } else + if (std::strcmp(pName, "vkQueueWaitIdle") == 0) { + return reinterpret_cast(&vkQueueWaitIdle); + } else + if (std::strcmp(pName, "vkDeviceWaitIdle") == 0) { + return reinterpret_cast(&vkDeviceWaitIdle); + } else + if (std::strcmp(pName, "vkAllocateMemory") == 0) { + return reinterpret_cast(&vkAllocateMemory); + } else + if (std::strcmp(pName, "vkFreeMemory") == 0) { + return reinterpret_cast(&vkFreeMemory); + } else + if (std::strcmp(pName, "vkMapMemory") == 0) { + return reinterpret_cast(&vkMapMemory); + } else + if (std::strcmp(pName, "vkUnmapMemory") == 0) { + return reinterpret_cast(&vkUnmapMemory); + } else + if (std::strcmp(pName, "vkFlushMappedMemoryRanges") == 0) { + return reinterpret_cast(&vkFlushMappedMemoryRanges); + } else + if (std::strcmp(pName, "vkInvalidateMappedMemoryRanges") == 0) { + return reinterpret_cast(&vkInvalidateMappedMemoryRanges); + } else + if (std::strcmp(pName, "vkGetDeviceMemoryCommitment") == 0) { + return reinterpret_cast(&vkGetDeviceMemoryCommitment); + } else + if (std::strcmp(pName, "vkGetBufferMemoryRequirements") == 0) { + return reinterpret_cast(&vkGetBufferMemoryRequirements); + } else + if (std::strcmp(pName, "vkBindBufferMemory") == 0) { + return reinterpret_cast(&vkBindBufferMemory); + } else + if (std::strcmp(pName, "vkGetImageMemoryRequirements") == 0) { + return reinterpret_cast(&vkGetImageMemoryRequirements); + } else + if (std::strcmp(pName, "vkBindImageMemory") == 0) { + return reinterpret_cast(&vkBindImageMemory); + } else + if (std::strcmp(pName, "vkGetImageSparseMemoryRequirements") == 0) { + return reinterpret_cast(&vkGetImageSparseMemoryRequirements); + } else + if (std::strcmp(pName, "vkQueueBindSparse") == 0) { + return reinterpret_cast(&vkQueueBindSparse); + } else + if (std::strcmp(pName, "vkCreateFence") == 0) { + return reinterpret_cast(&vkCreateFence); + } else + if (std::strcmp(pName, "vkDestroyFence") == 0) { + return reinterpret_cast(&vkDestroyFence); + } else + if (std::strcmp(pName, "vkResetFences") == 0) { + return reinterpret_cast(&vkResetFences); + } else + if (std::strcmp(pName, "vkGetFenceStatus") == 0) { + return reinterpret_cast(&vkGetFenceStatus); + } else + if (std::strcmp(pName, "vkWaitForFences") == 0) { + return reinterpret_cast(&vkWaitForFences); + } else + if (std::strcmp(pName, "vkCreateSemaphore") == 0) { + return reinterpret_cast(&vkCreateSemaphore); + } else + if (std::strcmp(pName, "vkDestroySemaphore") == 0) { + return reinterpret_cast(&vkDestroySemaphore); + } else + if (std::strcmp(pName, "vkCreateEvent") == 0) { + return reinterpret_cast(&vkCreateEvent); + } else + if (std::strcmp(pName, "vkDestroyEvent") == 0) { + return reinterpret_cast(&vkDestroyEvent); + } else + if (std::strcmp(pName, "vkGetEventStatus") == 0) { + return reinterpret_cast(&vkGetEventStatus); + } else + if (std::strcmp(pName, "vkSetEvent") == 0) { + return reinterpret_cast(&vkSetEvent); + } else + if (std::strcmp(pName, "vkResetEvent") == 0) { + return reinterpret_cast(&vkResetEvent); + } else + if (std::strcmp(pName, "vkCreateQueryPool") == 0) { + return reinterpret_cast(&vkCreateQueryPool); + } else + if (std::strcmp(pName, "vkDestroyQueryPool") == 0) { + return reinterpret_cast(&vkDestroyQueryPool); + } else + if (std::strcmp(pName, "vkGetQueryPoolResults") == 0) { + return reinterpret_cast(&vkGetQueryPoolResults); + } else + if (std::strcmp(pName, "vkResetQueryPool") == 0) { + return reinterpret_cast(&vkResetQueryPool); + } else + if (std::strcmp(pName, "vkResetQueryPoolEXT") == 0) { + return reinterpret_cast(&vkResetQueryPool); + } else + if (std::strcmp(pName, "vkCreateBuffer") == 0) { + return reinterpret_cast(&vkCreateBuffer); + } else + if (std::strcmp(pName, "vkDestroyBuffer") == 0) { + return reinterpret_cast(&vkDestroyBuffer); + } else + if (std::strcmp(pName, "vkCreateBufferView") == 0) { + return reinterpret_cast(&vkCreateBufferView); + } else + if (std::strcmp(pName, "vkDestroyBufferView") == 0) { + return reinterpret_cast(&vkDestroyBufferView); + } else + if (std::strcmp(pName, "vkCreateImage") == 0) { + return reinterpret_cast(&vkCreateImage); + } else + if (std::strcmp(pName, "vkDestroyImage") == 0) { + return reinterpret_cast(&vkDestroyImage); + } else + if (std::strcmp(pName, "vkGetImageSubresourceLayout") == 0) { + return reinterpret_cast(&vkGetImageSubresourceLayout); + } else + if (std::strcmp(pName, "vkCreateImageView") == 0) { + return reinterpret_cast(&vkCreateImageView); + } else + if (std::strcmp(pName, "vkDestroyImageView") == 0) { + return reinterpret_cast(&vkDestroyImageView); + } else + if (std::strcmp(pName, "vkCreateShaderModule") == 0) { + return reinterpret_cast(&vkCreateShaderModule); + } else + if (std::strcmp(pName, "vkDestroyShaderModule") == 0) { + return reinterpret_cast(&vkDestroyShaderModule); + } else + if (std::strcmp(pName, "vkCreatePipelineCache") == 0) { + return reinterpret_cast(&vkCreatePipelineCache); + } else + if (std::strcmp(pName, "vkDestroyPipelineCache") == 0) { + return reinterpret_cast(&vkDestroyPipelineCache); + } else + if (std::strcmp(pName, "vkGetPipelineCacheData") == 0) { + return reinterpret_cast(&vkGetPipelineCacheData); + } else + if (std::strcmp(pName, "vkMergePipelineCaches") == 0) { + return reinterpret_cast(&vkMergePipelineCaches); + } else + if (std::strcmp(pName, "vkCreateGraphicsPipelines") == 0) { + return reinterpret_cast(&vkCreateGraphicsPipelines); + } else + if (std::strcmp(pName, "vkCreateComputePipelines") == 0) { + return reinterpret_cast(&vkCreateComputePipelines); + } else + if (std::strcmp(pName, "vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI") == 0) { + return reinterpret_cast(&vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI); + } else + if (std::strcmp(pName, "vkDestroyPipeline") == 0) { + return reinterpret_cast(&vkDestroyPipeline); + } else + if (std::strcmp(pName, "vkCreatePipelineLayout") == 0) { + return reinterpret_cast(&vkCreatePipelineLayout); + } else + if (std::strcmp(pName, "vkDestroyPipelineLayout") == 0) { + return reinterpret_cast(&vkDestroyPipelineLayout); + } else + if (std::strcmp(pName, "vkCreateSampler") == 0) { + return reinterpret_cast(&vkCreateSampler); + } else + if (std::strcmp(pName, "vkDestroySampler") == 0) { + return reinterpret_cast(&vkDestroySampler); + } else + if (std::strcmp(pName, "vkCreateDescriptorSetLayout") == 0) { + return reinterpret_cast(&vkCreateDescriptorSetLayout); + } else + if (std::strcmp(pName, "vkDestroyDescriptorSetLayout") == 0) { + return reinterpret_cast(&vkDestroyDescriptorSetLayout); + } else + if (std::strcmp(pName, "vkCreateDescriptorPool") == 0) { + return reinterpret_cast(&vkCreateDescriptorPool); + } else + if (std::strcmp(pName, "vkDestroyDescriptorPool") == 0) { + return reinterpret_cast(&vkDestroyDescriptorPool); + } else + if (std::strcmp(pName, "vkResetDescriptorPool") == 0) { + return reinterpret_cast(&vkResetDescriptorPool); + } else + if (std::strcmp(pName, "vkAllocateDescriptorSets") == 0) { + return reinterpret_cast(&vkAllocateDescriptorSets); + } else + if (std::strcmp(pName, "vkFreeDescriptorSets") == 0) { + return reinterpret_cast(&vkFreeDescriptorSets); + } else + if (std::strcmp(pName, "vkUpdateDescriptorSets") == 0) { + return reinterpret_cast(&vkUpdateDescriptorSets); + } else + if (std::strcmp(pName, "vkCreateFramebuffer") == 0) { + return reinterpret_cast(&vkCreateFramebuffer); + } else + if (std::strcmp(pName, "vkDestroyFramebuffer") == 0) { + return reinterpret_cast(&vkDestroyFramebuffer); + } else + if (std::strcmp(pName, "vkCreateRenderPass") == 0) { + return reinterpret_cast(&vkCreateRenderPass); + } else + if (std::strcmp(pName, "vkDestroyRenderPass") == 0) { + return reinterpret_cast(&vkDestroyRenderPass); + } else + if (std::strcmp(pName, "vkGetRenderAreaGranularity") == 0) { + return reinterpret_cast(&vkGetRenderAreaGranularity); + } else + if (std::strcmp(pName, "vkCreateCommandPool") == 0) { + return reinterpret_cast(&vkCreateCommandPool); + } else + if (std::strcmp(pName, "vkDestroyCommandPool") == 0) { + return reinterpret_cast(&vkDestroyCommandPool); + } else + if (std::strcmp(pName, "vkResetCommandPool") == 0) { + return reinterpret_cast(&vkResetCommandPool); + } else + if (std::strcmp(pName, "vkAllocateCommandBuffers") == 0) { + return reinterpret_cast(&vkAllocateCommandBuffers); + } else + if (std::strcmp(pName, "vkFreeCommandBuffers") == 0) { + return reinterpret_cast(&vkFreeCommandBuffers); + } else + if (std::strcmp(pName, "vkBeginCommandBuffer") == 0) { + return reinterpret_cast(&vkBeginCommandBuffer); + } else + if (std::strcmp(pName, "vkEndCommandBuffer") == 0) { + return reinterpret_cast(&vkEndCommandBuffer); + } else + if (std::strcmp(pName, "vkResetCommandBuffer") == 0) { + return reinterpret_cast(&vkResetCommandBuffer); + } else + if (std::strcmp(pName, "vkCmdBindPipeline") == 0) { + return reinterpret_cast(&vkCmdBindPipeline); + } else + if (std::strcmp(pName, "vkCmdSetViewport") == 0) { + return reinterpret_cast(&vkCmdSetViewport); + } else + if (std::strcmp(pName, "vkCmdSetScissor") == 0) { + return reinterpret_cast(&vkCmdSetScissor); + } else + if (std::strcmp(pName, "vkCmdSetLineWidth") == 0) { + return reinterpret_cast(&vkCmdSetLineWidth); + } else + if (std::strcmp(pName, "vkCmdSetDepthBias") == 0) { + return reinterpret_cast(&vkCmdSetDepthBias); + } else + if (std::strcmp(pName, "vkCmdSetBlendConstants") == 0) { + return reinterpret_cast(&vkCmdSetBlendConstants); + } else + if (std::strcmp(pName, "vkCmdSetDepthBounds") == 0) { + return reinterpret_cast(&vkCmdSetDepthBounds); + } else + if (std::strcmp(pName, "vkCmdSetStencilCompareMask") == 0) { + return reinterpret_cast(&vkCmdSetStencilCompareMask); + } else + if (std::strcmp(pName, "vkCmdSetStencilWriteMask") == 0) { + return reinterpret_cast(&vkCmdSetStencilWriteMask); + } else + if (std::strcmp(pName, "vkCmdSetStencilReference") == 0) { + return reinterpret_cast(&vkCmdSetStencilReference); + } else + if (std::strcmp(pName, "vkCmdBindDescriptorSets") == 0) { + return reinterpret_cast(&vkCmdBindDescriptorSets); + } else + if (std::strcmp(pName, "vkCmdBindIndexBuffer") == 0) { + return reinterpret_cast(&vkCmdBindIndexBuffer); + } else + if (std::strcmp(pName, "vkCmdBindVertexBuffers") == 0) { + return reinterpret_cast(&vkCmdBindVertexBuffers); + } else + if (std::strcmp(pName, "vkCmdDraw") == 0) { + return reinterpret_cast(&vkCmdDraw); + } else + if (std::strcmp(pName, "vkCmdDrawIndexed") == 0) { + return reinterpret_cast(&vkCmdDrawIndexed); + } else + if (std::strcmp(pName, "vkCmdDrawMultiEXT") == 0) { + return reinterpret_cast(&vkCmdDrawMultiEXT); + } else + if (std::strcmp(pName, "vkCmdDrawMultiIndexedEXT") == 0) { + return reinterpret_cast(&vkCmdDrawMultiIndexedEXT); + } else + if (std::strcmp(pName, "vkCmdDrawIndirect") == 0) { + return reinterpret_cast(&vkCmdDrawIndirect); + } else + if (std::strcmp(pName, "vkCmdDrawIndexedIndirect") == 0) { + return reinterpret_cast(&vkCmdDrawIndexedIndirect); + } else + if (std::strcmp(pName, "vkCmdDispatch") == 0) { + return reinterpret_cast(&vkCmdDispatch); + } else + if (std::strcmp(pName, "vkCmdDispatchIndirect") == 0) { + return reinterpret_cast(&vkCmdDispatchIndirect); + } else + if (std::strcmp(pName, "vkCmdSubpassShadingHUAWEI") == 0) { + return reinterpret_cast(&vkCmdSubpassShadingHUAWEI); + } else + if (std::strcmp(pName, "vkCmdCopyBuffer") == 0) { + return reinterpret_cast(&vkCmdCopyBuffer); + } else + if (std::strcmp(pName, "vkCmdCopyImage") == 0) { + return reinterpret_cast(&vkCmdCopyImage); + } else + if (std::strcmp(pName, "vkCmdBlitImage") == 0) { + return reinterpret_cast(&vkCmdBlitImage); + } else + if (std::strcmp(pName, "vkCmdCopyBufferToImage") == 0) { + return reinterpret_cast(&vkCmdCopyBufferToImage); + } else + if (std::strcmp(pName, "vkCmdCopyImageToBuffer") == 0) { + return reinterpret_cast(&vkCmdCopyImageToBuffer); + } else + if (std::strcmp(pName, "vkCmdUpdateBuffer") == 0) { + return reinterpret_cast(&vkCmdUpdateBuffer); + } else + if (std::strcmp(pName, "vkCmdFillBuffer") == 0) { + return reinterpret_cast(&vkCmdFillBuffer); + } else + if (std::strcmp(pName, "vkCmdClearColorImage") == 0) { + return reinterpret_cast(&vkCmdClearColorImage); + } else + if (std::strcmp(pName, "vkCmdClearDepthStencilImage") == 0) { + return reinterpret_cast(&vkCmdClearDepthStencilImage); + } else + if (std::strcmp(pName, "vkCmdClearAttachments") == 0) { + return reinterpret_cast(&vkCmdClearAttachments); + } else + if (std::strcmp(pName, "vkCmdResolveImage") == 0) { + return reinterpret_cast(&vkCmdResolveImage); + } else + if (std::strcmp(pName, "vkCmdSetEvent") == 0) { + return reinterpret_cast(&vkCmdSetEvent); + } else + if (std::strcmp(pName, "vkCmdResetEvent") == 0) { + return reinterpret_cast(&vkCmdResetEvent); + } else + if (std::strcmp(pName, "vkCmdWaitEvents") == 0) { + return reinterpret_cast(&vkCmdWaitEvents); + } else + if (std::strcmp(pName, "vkCmdPipelineBarrier") == 0) { + return reinterpret_cast(&vkCmdPipelineBarrier); + } else + if (std::strcmp(pName, "vkCmdBeginQuery") == 0) { + return reinterpret_cast(&vkCmdBeginQuery); + } else + if (std::strcmp(pName, "vkCmdEndQuery") == 0) { + return reinterpret_cast(&vkCmdEndQuery); + } else + if (std::strcmp(pName, "vkCmdBeginConditionalRenderingEXT") == 0) { + return reinterpret_cast(&vkCmdBeginConditionalRenderingEXT); + } else + if (std::strcmp(pName, "vkCmdEndConditionalRenderingEXT") == 0) { + return reinterpret_cast(&vkCmdEndConditionalRenderingEXT); + } else + if (std::strcmp(pName, "vkCmdResetQueryPool") == 0) { + return reinterpret_cast(&vkCmdResetQueryPool); + } else + if (std::strcmp(pName, "vkCmdWriteTimestamp") == 0) { + return reinterpret_cast(&vkCmdWriteTimestamp); + } else + if (std::strcmp(pName, "vkCmdCopyQueryPoolResults") == 0) { + return reinterpret_cast(&vkCmdCopyQueryPoolResults); + } else + if (std::strcmp(pName, "vkCmdPushConstants") == 0) { + return reinterpret_cast(&vkCmdPushConstants); + } else + if (std::strcmp(pName, "vkCmdBeginRenderPass") == 0) { + return reinterpret_cast(&vkCmdBeginRenderPass); + } else + if (std::strcmp(pName, "vkCmdNextSubpass") == 0) { + return reinterpret_cast(&vkCmdNextSubpass); + } else + if (std::strcmp(pName, "vkCmdEndRenderPass") == 0) { + return reinterpret_cast(&vkCmdEndRenderPass); + } else + if (std::strcmp(pName, "vkCmdExecuteCommands") == 0) { + return reinterpret_cast(&vkCmdExecuteCommands); + } else + if (std::strcmp(pName, "vkCreateSharedSwapchainsKHR") == 0) { + return reinterpret_cast(&vkCreateSharedSwapchainsKHR); + } else + if (std::strcmp(pName, "vkCreateSwapchainKHR") == 0) { + return reinterpret_cast(&vkCreateSwapchainKHR); + } else + if (std::strcmp(pName, "vkDestroySwapchainKHR") == 0) { + return reinterpret_cast(&vkDestroySwapchainKHR); + } else + if (std::strcmp(pName, "vkGetSwapchainImagesKHR") == 0) { + return reinterpret_cast(&vkGetSwapchainImagesKHR); + } else + if (std::strcmp(pName, "vkAcquireNextImageKHR") == 0) { + return reinterpret_cast(&vkAcquireNextImageKHR); + } else + if (std::strcmp(pName, "vkQueuePresentKHR") == 0) { + return reinterpret_cast(&vkQueuePresentKHR); + } else + if (std::strcmp(pName, "vkDebugMarkerSetObjectNameEXT") == 0) { + return reinterpret_cast(&vkDebugMarkerSetObjectNameEXT); + } else + if (std::strcmp(pName, "vkDebugMarkerSetObjectTagEXT") == 0) { + return reinterpret_cast(&vkDebugMarkerSetObjectTagEXT); + } else + if (std::strcmp(pName, "vkCmdDebugMarkerBeginEXT") == 0) { + return reinterpret_cast(&vkCmdDebugMarkerBeginEXT); + } else + if (std::strcmp(pName, "vkCmdDebugMarkerEndEXT") == 0) { + return reinterpret_cast(&vkCmdDebugMarkerEndEXT); + } else + if (std::strcmp(pName, "vkCmdDebugMarkerInsertEXT") == 0) { + return reinterpret_cast(&vkCmdDebugMarkerInsertEXT); + } else + if (std::strcmp(pName, "vkCmdExecuteGeneratedCommandsNV") == 0) { + return reinterpret_cast(&vkCmdExecuteGeneratedCommandsNV); + } else + if (std::strcmp(pName, "vkCmdPreprocessGeneratedCommandsNV") == 0) { + return reinterpret_cast(&vkCmdPreprocessGeneratedCommandsNV); + } else + if (std::strcmp(pName, "vkCmdBindPipelineShaderGroupNV") == 0) { + return reinterpret_cast(&vkCmdBindPipelineShaderGroupNV); + } else + if (std::strcmp(pName, "vkGetGeneratedCommandsMemoryRequirementsNV") == 0) { + return reinterpret_cast(&vkGetGeneratedCommandsMemoryRequirementsNV); + } else + if (std::strcmp(pName, "vkCreateIndirectCommandsLayoutNV") == 0) { + return reinterpret_cast(&vkCreateIndirectCommandsLayoutNV); + } else + if (std::strcmp(pName, "vkDestroyIndirectCommandsLayoutNV") == 0) { + return reinterpret_cast(&vkDestroyIndirectCommandsLayoutNV); + } else + if (std::strcmp(pName, "vkCmdPushDescriptorSetKHR") == 0) { + return reinterpret_cast(&vkCmdPushDescriptorSetKHR); + } else + if (std::strcmp(pName, "vkTrimCommandPool") == 0) { + return reinterpret_cast(&vkTrimCommandPool); + } else + if (std::strcmp(pName, "vkTrimCommandPoolKHR") == 0) { + return reinterpret_cast(&vkTrimCommandPool); + } else + if (std::strcmp(pName, "vkGetMemoryFdKHR") == 0) { + return reinterpret_cast(&vkGetMemoryFdKHR); + } else + if (std::strcmp(pName, "vkGetMemoryFdPropertiesKHR") == 0) { + return reinterpret_cast(&vkGetMemoryFdPropertiesKHR); + } else + if (std::strcmp(pName, "vkGetMemoryRemoteAddressNV") == 0) { + return reinterpret_cast(&vkGetMemoryRemoteAddressNV); + } else + if (std::strcmp(pName, "vkGetSemaphoreFdKHR") == 0) { + return reinterpret_cast(&vkGetSemaphoreFdKHR); + } else + if (std::strcmp(pName, "vkImportSemaphoreFdKHR") == 0) { + return reinterpret_cast(&vkImportSemaphoreFdKHR); + } else + if (std::strcmp(pName, "vkGetFenceFdKHR") == 0) { + return reinterpret_cast(&vkGetFenceFdKHR); + } else + if (std::strcmp(pName, "vkImportFenceFdKHR") == 0) { + return reinterpret_cast(&vkImportFenceFdKHR); + } else + if (std::strcmp(pName, "vkDisplayPowerControlEXT") == 0) { + return reinterpret_cast(&vkDisplayPowerControlEXT); + } else + if (std::strcmp(pName, "vkRegisterDeviceEventEXT") == 0) { + return reinterpret_cast(&vkRegisterDeviceEventEXT); + } else + if (std::strcmp(pName, "vkRegisterDisplayEventEXT") == 0) { + return reinterpret_cast(&vkRegisterDisplayEventEXT); + } else + if (std::strcmp(pName, "vkGetSwapchainCounterEXT") == 0) { + return reinterpret_cast(&vkGetSwapchainCounterEXT); + } else + if (std::strcmp(pName, "vkGetDeviceGroupPeerMemoryFeatures") == 0) { + return reinterpret_cast(&vkGetDeviceGroupPeerMemoryFeatures); + } else + if (std::strcmp(pName, "vkGetDeviceGroupPeerMemoryFeaturesKHR") == 0) { + return reinterpret_cast(&vkGetDeviceGroupPeerMemoryFeatures); + } else + if (std::strcmp(pName, "vkBindBufferMemory2") == 0) { + return reinterpret_cast(&vkBindBufferMemory2); + } else + if (std::strcmp(pName, "vkBindBufferMemory2KHR") == 0) { + return reinterpret_cast(&vkBindBufferMemory2); + } else + if (std::strcmp(pName, "vkBindImageMemory2") == 0) { + return reinterpret_cast(&vkBindImageMemory2); + } else + if (std::strcmp(pName, "vkBindImageMemory2KHR") == 0) { + return reinterpret_cast(&vkBindImageMemory2); + } else + if (std::strcmp(pName, "vkCmdSetDeviceMask") == 0) { + return reinterpret_cast(&vkCmdSetDeviceMask); + } else + if (std::strcmp(pName, "vkCmdSetDeviceMaskKHR") == 0) { + return reinterpret_cast(&vkCmdSetDeviceMask); + } else + if (std::strcmp(pName, "vkGetDeviceGroupPresentCapabilitiesKHR") == 0) { + return reinterpret_cast(&vkGetDeviceGroupPresentCapabilitiesKHR); + } else + if (std::strcmp(pName, "vkGetDeviceGroupSurfacePresentModesKHR") == 0) { + return reinterpret_cast(&vkGetDeviceGroupSurfacePresentModesKHR); + } else + if (std::strcmp(pName, "vkAcquireNextImage2KHR") == 0) { + return reinterpret_cast(&vkAcquireNextImage2KHR); + } else + if (std::strcmp(pName, "vkCmdDispatchBase") == 0) { + return reinterpret_cast(&vkCmdDispatchBase); + } else + if (std::strcmp(pName, "vkCmdDispatchBaseKHR") == 0) { + return reinterpret_cast(&vkCmdDispatchBase); + } else + if (std::strcmp(pName, "vkCreateDescriptorUpdateTemplate") == 0) { + return reinterpret_cast(&vkCreateDescriptorUpdateTemplate); + } else + if (std::strcmp(pName, "vkCreateDescriptorUpdateTemplateKHR") == 0) { + return reinterpret_cast(&vkCreateDescriptorUpdateTemplate); + } else + if (std::strcmp(pName, "vkDestroyDescriptorUpdateTemplate") == 0) { + return reinterpret_cast(&vkDestroyDescriptorUpdateTemplate); + } else + if (std::strcmp(pName, "vkDestroyDescriptorUpdateTemplateKHR") == 0) { + return reinterpret_cast(&vkDestroyDescriptorUpdateTemplate); + } else + if (std::strcmp(pName, "vkUpdateDescriptorSetWithTemplate") == 0) { + return reinterpret_cast(&vkUpdateDescriptorSetWithTemplate); + } else + if (std::strcmp(pName, "vkUpdateDescriptorSetWithTemplateKHR") == 0) { + return reinterpret_cast(&vkUpdateDescriptorSetWithTemplate); + } else + if (std::strcmp(pName, "vkCmdPushDescriptorSetWithTemplateKHR") == 0) { + return reinterpret_cast(&vkCmdPushDescriptorSetWithTemplateKHR); + } else + if (std::strcmp(pName, "vkSetHdrMetadataEXT") == 0) { + return reinterpret_cast(&vkSetHdrMetadataEXT); + } else + if (std::strcmp(pName, "vkGetSwapchainStatusKHR") == 0) { + return reinterpret_cast(&vkGetSwapchainStatusKHR); + } else + if (std::strcmp(pName, "vkGetRefreshCycleDurationGOOGLE") == 0) { + return reinterpret_cast(&vkGetRefreshCycleDurationGOOGLE); + } else + if (std::strcmp(pName, "vkGetPastPresentationTimingGOOGLE") == 0) { + return reinterpret_cast(&vkGetPastPresentationTimingGOOGLE); + } else + if (std::strcmp(pName, "vkCmdSetViewportWScalingNV") == 0) { + return reinterpret_cast(&vkCmdSetViewportWScalingNV); + } else + if (std::strcmp(pName, "vkCmdSetDiscardRectangleEXT") == 0) { + return reinterpret_cast(&vkCmdSetDiscardRectangleEXT); + } else + if (std::strcmp(pName, "vkCmdSetSampleLocationsEXT") == 0) { + return reinterpret_cast(&vkCmdSetSampleLocationsEXT); + } else + if (std::strcmp(pName, "vkGetBufferMemoryRequirements2") == 0) { + return reinterpret_cast(&vkGetBufferMemoryRequirements2); + } else + if (std::strcmp(pName, "vkGetBufferMemoryRequirements2KHR") == 0) { + return reinterpret_cast(&vkGetBufferMemoryRequirements2); + } else + if (std::strcmp(pName, "vkGetImageMemoryRequirements2") == 0) { + return reinterpret_cast(&vkGetImageMemoryRequirements2); + } else + if (std::strcmp(pName, "vkGetImageMemoryRequirements2KHR") == 0) { + return reinterpret_cast(&vkGetImageMemoryRequirements2); + } else + if (std::strcmp(pName, "vkGetImageSparseMemoryRequirements2") == 0) { + return reinterpret_cast(&vkGetImageSparseMemoryRequirements2); + } else + if (std::strcmp(pName, "vkGetImageSparseMemoryRequirements2KHR") == 0) { + return reinterpret_cast(&vkGetImageSparseMemoryRequirements2); + } else + if (std::strcmp(pName, "vkGetDeviceBufferMemoryRequirements") == 0) { + return reinterpret_cast(&vkGetDeviceBufferMemoryRequirements); + } else + if (std::strcmp(pName, "vkGetDeviceBufferMemoryRequirementsKHR") == 0) { + return reinterpret_cast(&vkGetDeviceBufferMemoryRequirements); + } else + if (std::strcmp(pName, "vkGetDeviceImageMemoryRequirements") == 0) { + return reinterpret_cast(&vkGetDeviceImageMemoryRequirements); + } else + if (std::strcmp(pName, "vkGetDeviceImageMemoryRequirementsKHR") == 0) { + return reinterpret_cast(&vkGetDeviceImageMemoryRequirements); + } else + if (std::strcmp(pName, "vkGetDeviceImageSparseMemoryRequirements") == 0) { + return reinterpret_cast(&vkGetDeviceImageSparseMemoryRequirements); + } else + if (std::strcmp(pName, "vkGetDeviceImageSparseMemoryRequirementsKHR") == 0) { + return reinterpret_cast(&vkGetDeviceImageSparseMemoryRequirements); + } else + if (std::strcmp(pName, "vkCreateSamplerYcbcrConversion") == 0) { + return reinterpret_cast(&vkCreateSamplerYcbcrConversion); + } else + if (std::strcmp(pName, "vkCreateSamplerYcbcrConversionKHR") == 0) { + return reinterpret_cast(&vkCreateSamplerYcbcrConversion); + } else + if (std::strcmp(pName, "vkDestroySamplerYcbcrConversion") == 0) { + return reinterpret_cast(&vkDestroySamplerYcbcrConversion); + } else + if (std::strcmp(pName, "vkDestroySamplerYcbcrConversionKHR") == 0) { + return reinterpret_cast(&vkDestroySamplerYcbcrConversion); + } else + if (std::strcmp(pName, "vkGetDeviceQueue2") == 0) { + return reinterpret_cast(&vkGetDeviceQueue2); + } else + if (std::strcmp(pName, "vkCreateValidationCacheEXT") == 0) { + return reinterpret_cast(&vkCreateValidationCacheEXT); + } else + if (std::strcmp(pName, "vkDestroyValidationCacheEXT") == 0) { + return reinterpret_cast(&vkDestroyValidationCacheEXT); + } else + if (std::strcmp(pName, "vkGetValidationCacheDataEXT") == 0) { + return reinterpret_cast(&vkGetValidationCacheDataEXT); + } else + if (std::strcmp(pName, "vkMergeValidationCachesEXT") == 0) { + return reinterpret_cast(&vkMergeValidationCachesEXT); + } else + if (std::strcmp(pName, "vkGetDescriptorSetLayoutSupport") == 0) { + return reinterpret_cast(&vkGetDescriptorSetLayoutSupport); + } else + if (std::strcmp(pName, "vkGetDescriptorSetLayoutSupportKHR") == 0) { + return reinterpret_cast(&vkGetDescriptorSetLayoutSupport); + } else + if (std::strcmp(pName, "vkGetShaderInfoAMD") == 0) { + return reinterpret_cast(&vkGetShaderInfoAMD); + } else + if (std::strcmp(pName, "vkSetLocalDimmingAMD") == 0) { + return reinterpret_cast(&vkSetLocalDimmingAMD); + } else + if (std::strcmp(pName, "vkGetCalibratedTimestampsEXT") == 0) { + return reinterpret_cast(&vkGetCalibratedTimestampsEXT); + } else + if (std::strcmp(pName, "vkSetDebugUtilsObjectNameEXT") == 0) { + return reinterpret_cast(&vkSetDebugUtilsObjectNameEXT); + } else + if (std::strcmp(pName, "vkSetDebugUtilsObjectTagEXT") == 0) { + return reinterpret_cast(&vkSetDebugUtilsObjectTagEXT); + } else + if (std::strcmp(pName, "vkQueueBeginDebugUtilsLabelEXT") == 0) { + return reinterpret_cast(&vkQueueBeginDebugUtilsLabelEXT); + } else + if (std::strcmp(pName, "vkQueueEndDebugUtilsLabelEXT") == 0) { + return reinterpret_cast(&vkQueueEndDebugUtilsLabelEXT); + } else + if (std::strcmp(pName, "vkQueueInsertDebugUtilsLabelEXT") == 0) { + return reinterpret_cast(&vkQueueInsertDebugUtilsLabelEXT); + } else + if (std::strcmp(pName, "vkCmdBeginDebugUtilsLabelEXT") == 0) { + return reinterpret_cast(&vkCmdBeginDebugUtilsLabelEXT); + } else + if (std::strcmp(pName, "vkCmdEndDebugUtilsLabelEXT") == 0) { + return reinterpret_cast(&vkCmdEndDebugUtilsLabelEXT); + } else + if (std::strcmp(pName, "vkCmdInsertDebugUtilsLabelEXT") == 0) { + return reinterpret_cast(&vkCmdInsertDebugUtilsLabelEXT); + } else + if (std::strcmp(pName, "vkGetMemoryHostPointerPropertiesEXT") == 0) { + return reinterpret_cast(&vkGetMemoryHostPointerPropertiesEXT); + } else + if (std::strcmp(pName, "vkCmdWriteBufferMarkerAMD") == 0) { + return reinterpret_cast(&vkCmdWriteBufferMarkerAMD); + } else + if (std::strcmp(pName, "vkCreateRenderPass2") == 0) { + return reinterpret_cast(&vkCreateRenderPass2); + } else + if (std::strcmp(pName, "vkCreateRenderPass2KHR") == 0) { + return reinterpret_cast(&vkCreateRenderPass2); + } else + if (std::strcmp(pName, "vkCmdBeginRenderPass2") == 0) { + return reinterpret_cast(&vkCmdBeginRenderPass2); + } else + if (std::strcmp(pName, "vkCmdBeginRenderPass2KHR") == 0) { + return reinterpret_cast(&vkCmdBeginRenderPass2); + } else + if (std::strcmp(pName, "vkCmdNextSubpass2") == 0) { + return reinterpret_cast(&vkCmdNextSubpass2); + } else + if (std::strcmp(pName, "vkCmdNextSubpass2KHR") == 0) { + return reinterpret_cast(&vkCmdNextSubpass2); + } else + if (std::strcmp(pName, "vkCmdEndRenderPass2") == 0) { + return reinterpret_cast(&vkCmdEndRenderPass2); + } else + if (std::strcmp(pName, "vkCmdEndRenderPass2KHR") == 0) { + return reinterpret_cast(&vkCmdEndRenderPass2); + } else + if (std::strcmp(pName, "vkGetSemaphoreCounterValue") == 0) { + return reinterpret_cast(&vkGetSemaphoreCounterValue); + } else + if (std::strcmp(pName, "vkGetSemaphoreCounterValueKHR") == 0) { + return reinterpret_cast(&vkGetSemaphoreCounterValue); + } else + if (std::strcmp(pName, "vkWaitSemaphores") == 0) { + return reinterpret_cast(&vkWaitSemaphores); + } else + if (std::strcmp(pName, "vkWaitSemaphoresKHR") == 0) { + return reinterpret_cast(&vkWaitSemaphores); + } else + if (std::strcmp(pName, "vkSignalSemaphore") == 0) { + return reinterpret_cast(&vkSignalSemaphore); + } else + if (std::strcmp(pName, "vkSignalSemaphoreKHR") == 0) { + return reinterpret_cast(&vkSignalSemaphore); + } else + if (std::strcmp(pName, "vkCmdDrawIndirectCount") == 0) { + return reinterpret_cast(&vkCmdDrawIndirectCount); + } else + if (std::strcmp(pName, "vkCmdDrawIndirectCountKHR") == 0) { + return reinterpret_cast(&vkCmdDrawIndirectCount); + } else + if (std::strcmp(pName, "vkCmdDrawIndirectCountAMD") == 0) { + return reinterpret_cast(&vkCmdDrawIndirectCount); + } else + if (std::strcmp(pName, "vkCmdDrawIndexedIndirectCount") == 0) { + return reinterpret_cast(&vkCmdDrawIndexedIndirectCount); + } else + if (std::strcmp(pName, "vkCmdDrawIndexedIndirectCountKHR") == 0) { + return reinterpret_cast(&vkCmdDrawIndexedIndirectCount); + } else + if (std::strcmp(pName, "vkCmdDrawIndexedIndirectCountAMD") == 0) { + return reinterpret_cast(&vkCmdDrawIndexedIndirectCount); + } else + if (std::strcmp(pName, "vkCmdSetCheckpointNV") == 0) { + return reinterpret_cast(&vkCmdSetCheckpointNV); + } else + if (std::strcmp(pName, "vkGetQueueCheckpointDataNV") == 0) { + return reinterpret_cast(&vkGetQueueCheckpointDataNV); + } else + if (std::strcmp(pName, "vkCmdBindTransformFeedbackBuffersEXT") == 0) { + return reinterpret_cast(&vkCmdBindTransformFeedbackBuffersEXT); + } else + if (std::strcmp(pName, "vkCmdBeginTransformFeedbackEXT") == 0) { + return reinterpret_cast(&vkCmdBeginTransformFeedbackEXT); + } else + if (std::strcmp(pName, "vkCmdEndTransformFeedbackEXT") == 0) { + return reinterpret_cast(&vkCmdEndTransformFeedbackEXT); + } else + if (std::strcmp(pName, "vkCmdBeginQueryIndexedEXT") == 0) { + return reinterpret_cast(&vkCmdBeginQueryIndexedEXT); + } else + if (std::strcmp(pName, "vkCmdEndQueryIndexedEXT") == 0) { + return reinterpret_cast(&vkCmdEndQueryIndexedEXT); + } else + if (std::strcmp(pName, "vkCmdDrawIndirectByteCountEXT") == 0) { + return reinterpret_cast(&vkCmdDrawIndirectByteCountEXT); + } else + if (std::strcmp(pName, "vkCmdSetExclusiveScissorNV") == 0) { + return reinterpret_cast(&vkCmdSetExclusiveScissorNV); + } else + if (std::strcmp(pName, "vkCmdBindShadingRateImageNV") == 0) { + return reinterpret_cast(&vkCmdBindShadingRateImageNV); + } else + if (std::strcmp(pName, "vkCmdSetViewportShadingRatePaletteNV") == 0) { + return reinterpret_cast(&vkCmdSetViewportShadingRatePaletteNV); + } else + if (std::strcmp(pName, "vkCmdSetCoarseSampleOrderNV") == 0) { + return reinterpret_cast(&vkCmdSetCoarseSampleOrderNV); + } else + if (std::strcmp(pName, "vkCmdDrawMeshTasksNV") == 0) { + return reinterpret_cast(&vkCmdDrawMeshTasksNV); + } else + if (std::strcmp(pName, "vkCmdDrawMeshTasksIndirectNV") == 0) { + return reinterpret_cast(&vkCmdDrawMeshTasksIndirectNV); + } else + if (std::strcmp(pName, "vkCmdDrawMeshTasksIndirectCountNV") == 0) { + return reinterpret_cast(&vkCmdDrawMeshTasksIndirectCountNV); + } else + if (std::strcmp(pName, "vkCompileDeferredNV") == 0) { + return reinterpret_cast(&vkCompileDeferredNV); + } else + if (std::strcmp(pName, "vkCreateAccelerationStructureNV") == 0) { + return reinterpret_cast(&vkCreateAccelerationStructureNV); + } else + if (std::strcmp(pName, "vkCmdBindInvocationMaskHUAWEI") == 0) { + return reinterpret_cast(&vkCmdBindInvocationMaskHUAWEI); + } else + if (std::strcmp(pName, "vkDestroyAccelerationStructureKHR") == 0) { + return reinterpret_cast(&vkDestroyAccelerationStructureKHR); + } else + if (std::strcmp(pName, "vkDestroyAccelerationStructureNV") == 0) { + return reinterpret_cast(&vkDestroyAccelerationStructureNV); + } else + if (std::strcmp(pName, "vkGetAccelerationStructureMemoryRequirementsNV") == 0) { + return reinterpret_cast(&vkGetAccelerationStructureMemoryRequirementsNV); + } else + if (std::strcmp(pName, "vkBindAccelerationStructureMemoryNV") == 0) { + return reinterpret_cast(&vkBindAccelerationStructureMemoryNV); + } else + if (std::strcmp(pName, "vkCmdCopyAccelerationStructureNV") == 0) { + return reinterpret_cast(&vkCmdCopyAccelerationStructureNV); + } else + if (std::strcmp(pName, "vkCmdCopyAccelerationStructureKHR") == 0) { + return reinterpret_cast(&vkCmdCopyAccelerationStructureKHR); + } else + if (std::strcmp(pName, "vkCopyAccelerationStructureKHR") == 0) { + return reinterpret_cast(&vkCopyAccelerationStructureKHR); + } else + if (std::strcmp(pName, "vkCmdCopyAccelerationStructureToMemoryKHR") == 0) { + return reinterpret_cast(&vkCmdCopyAccelerationStructureToMemoryKHR); + } else + if (std::strcmp(pName, "vkCopyAccelerationStructureToMemoryKHR") == 0) { + return reinterpret_cast(&vkCopyAccelerationStructureToMemoryKHR); + } else + if (std::strcmp(pName, "vkCmdCopyMemoryToAccelerationStructureKHR") == 0) { + return reinterpret_cast(&vkCmdCopyMemoryToAccelerationStructureKHR); + } else + if (std::strcmp(pName, "vkCopyMemoryToAccelerationStructureKHR") == 0) { + return reinterpret_cast(&vkCopyMemoryToAccelerationStructureKHR); + } else + if (std::strcmp(pName, "vkCmdWriteAccelerationStructuresPropertiesKHR") == 0) { + return reinterpret_cast(&vkCmdWriteAccelerationStructuresPropertiesKHR); + } else + if (std::strcmp(pName, "vkCmdWriteAccelerationStructuresPropertiesNV") == 0) { + return reinterpret_cast(&vkCmdWriteAccelerationStructuresPropertiesNV); + } else + if (std::strcmp(pName, "vkCmdBuildAccelerationStructureNV") == 0) { + return reinterpret_cast(&vkCmdBuildAccelerationStructureNV); + } else + if (std::strcmp(pName, "vkWriteAccelerationStructuresPropertiesKHR") == 0) { + return reinterpret_cast(&vkWriteAccelerationStructuresPropertiesKHR); + } else + if (std::strcmp(pName, "vkCmdTraceRaysKHR") == 0) { + return reinterpret_cast(&vkCmdTraceRaysKHR); + } else + if (std::strcmp(pName, "vkCmdTraceRaysNV") == 0) { + return reinterpret_cast(&vkCmdTraceRaysNV); + } else + if (std::strcmp(pName, "vkGetRayTracingShaderGroupHandlesKHR") == 0) { + return reinterpret_cast(&vkGetRayTracingShaderGroupHandlesKHR); + } else + if (std::strcmp(pName, "vkGetRayTracingShaderGroupHandlesNV") == 0) { + return reinterpret_cast(&vkGetRayTracingShaderGroupHandlesKHR); + } else + if (std::strcmp(pName, "vkGetRayTracingCaptureReplayShaderGroupHandlesKHR") == 0) { + return reinterpret_cast(&vkGetRayTracingCaptureReplayShaderGroupHandlesKHR); + } else + if (std::strcmp(pName, "vkGetAccelerationStructureHandleNV") == 0) { + return reinterpret_cast(&vkGetAccelerationStructureHandleNV); + } else + if (std::strcmp(pName, "vkCreateRayTracingPipelinesNV") == 0) { + return reinterpret_cast(&vkCreateRayTracingPipelinesNV); + } else + if (std::strcmp(pName, "vkCreateRayTracingPipelinesKHR") == 0) { + return reinterpret_cast(&vkCreateRayTracingPipelinesKHR); + } else + if (std::strcmp(pName, "vkCmdTraceRaysIndirectKHR") == 0) { + return reinterpret_cast(&vkCmdTraceRaysIndirectKHR); + } else + if (std::strcmp(pName, "vkCmdTraceRaysIndirect2KHR") == 0) { + return reinterpret_cast(&vkCmdTraceRaysIndirect2KHR); + } else + if (std::strcmp(pName, "vkGetDeviceAccelerationStructureCompatibilityKHR") == 0) { + return reinterpret_cast(&vkGetDeviceAccelerationStructureCompatibilityKHR); + } else + if (std::strcmp(pName, "vkGetRayTracingShaderGroupStackSizeKHR") == 0) { + return reinterpret_cast(&vkGetRayTracingShaderGroupStackSizeKHR); + } else + if (std::strcmp(pName, "vkCmdSetRayTracingPipelineStackSizeKHR") == 0) { + return reinterpret_cast(&vkCmdSetRayTracingPipelineStackSizeKHR); + } else + if (std::strcmp(pName, "vkGetImageViewHandleNVX") == 0) { + return reinterpret_cast(&vkGetImageViewHandleNVX); + } else + if (std::strcmp(pName, "vkGetImageViewAddressNVX") == 0) { + return reinterpret_cast(&vkGetImageViewAddressNVX); + } else + if (std::strcmp(pName, "vkAcquireProfilingLockKHR") == 0) { + return reinterpret_cast(&vkAcquireProfilingLockKHR); + } else + if (std::strcmp(pName, "vkReleaseProfilingLockKHR") == 0) { + return reinterpret_cast(&vkReleaseProfilingLockKHR); + } else + if (std::strcmp(pName, "vkGetImageDrmFormatModifierPropertiesEXT") == 0) { + return reinterpret_cast(&vkGetImageDrmFormatModifierPropertiesEXT); + } else + if (std::strcmp(pName, "vkGetBufferOpaqueCaptureAddress") == 0) { + return reinterpret_cast(&vkGetBufferOpaqueCaptureAddress); + } else + if (std::strcmp(pName, "vkGetBufferOpaqueCaptureAddressKHR") == 0) { + return reinterpret_cast(&vkGetBufferOpaqueCaptureAddress); + } else + if (std::strcmp(pName, "vkGetBufferDeviceAddress") == 0) { + return reinterpret_cast(&vkGetBufferDeviceAddress); + } else + if (std::strcmp(pName, "vkGetBufferDeviceAddressKHR") == 0) { + return reinterpret_cast(&vkGetBufferDeviceAddress); + } else + if (std::strcmp(pName, "vkGetBufferDeviceAddressEXT") == 0) { + return reinterpret_cast(&vkGetBufferDeviceAddress); + } else + if (std::strcmp(pName, "vkInitializePerformanceApiINTEL") == 0) { + return reinterpret_cast(&vkInitializePerformanceApiINTEL); + } else + if (std::strcmp(pName, "vkUninitializePerformanceApiINTEL") == 0) { + return reinterpret_cast(&vkUninitializePerformanceApiINTEL); + } else + if (std::strcmp(pName, "vkCmdSetPerformanceMarkerINTEL") == 0) { + return reinterpret_cast(&vkCmdSetPerformanceMarkerINTEL); + } else + if (std::strcmp(pName, "vkCmdSetPerformanceStreamMarkerINTEL") == 0) { + return reinterpret_cast(&vkCmdSetPerformanceStreamMarkerINTEL); + } else + if (std::strcmp(pName, "vkCmdSetPerformanceOverrideINTEL") == 0) { + return reinterpret_cast(&vkCmdSetPerformanceOverrideINTEL); + } else + if (std::strcmp(pName, "vkAcquirePerformanceConfigurationINTEL") == 0) { + return reinterpret_cast(&vkAcquirePerformanceConfigurationINTEL); + } else + if (std::strcmp(pName, "vkReleasePerformanceConfigurationINTEL") == 0) { + return reinterpret_cast(&vkReleasePerformanceConfigurationINTEL); + } else + if (std::strcmp(pName, "vkQueueSetPerformanceConfigurationINTEL") == 0) { + return reinterpret_cast(&vkQueueSetPerformanceConfigurationINTEL); + } else + if (std::strcmp(pName, "vkGetPerformanceParameterINTEL") == 0) { + return reinterpret_cast(&vkGetPerformanceParameterINTEL); + } else + if (std::strcmp(pName, "vkGetDeviceMemoryOpaqueCaptureAddress") == 0) { + return reinterpret_cast(&vkGetDeviceMemoryOpaqueCaptureAddress); + } else + if (std::strcmp(pName, "vkGetDeviceMemoryOpaqueCaptureAddressKHR") == 0) { + return reinterpret_cast(&vkGetDeviceMemoryOpaqueCaptureAddress); + } else + if (std::strcmp(pName, "vkGetPipelineExecutablePropertiesKHR") == 0) { + return reinterpret_cast(&vkGetPipelineExecutablePropertiesKHR); + } else + if (std::strcmp(pName, "vkGetPipelineExecutableStatisticsKHR") == 0) { + return reinterpret_cast(&vkGetPipelineExecutableStatisticsKHR); + } else + if (std::strcmp(pName, "vkGetPipelineExecutableInternalRepresentationsKHR") == 0) { + return reinterpret_cast(&vkGetPipelineExecutableInternalRepresentationsKHR); + } else + if (std::strcmp(pName, "vkCmdSetLineStippleEXT") == 0) { + return reinterpret_cast(&vkCmdSetLineStippleEXT); + } else + if (std::strcmp(pName, "vkCreateAccelerationStructureKHR") == 0) { + return reinterpret_cast(&vkCreateAccelerationStructureKHR); + } else + if (std::strcmp(pName, "vkCmdBuildAccelerationStructuresKHR") == 0) { + return reinterpret_cast(&vkCmdBuildAccelerationStructuresKHR); + } else + if (std::strcmp(pName, "vkCmdBuildAccelerationStructuresIndirectKHR") == 0) { + return reinterpret_cast(&vkCmdBuildAccelerationStructuresIndirectKHR); + } else + if (std::strcmp(pName, "vkBuildAccelerationStructuresKHR") == 0) { + return reinterpret_cast(&vkBuildAccelerationStructuresKHR); + } else + if (std::strcmp(pName, "vkGetAccelerationStructureDeviceAddressKHR") == 0) { + return reinterpret_cast(&vkGetAccelerationStructureDeviceAddressKHR); + } else + if (std::strcmp(pName, "vkCreateDeferredOperationKHR") == 0) { + return reinterpret_cast(&vkCreateDeferredOperationKHR); + } else + if (std::strcmp(pName, "vkDestroyDeferredOperationKHR") == 0) { + return reinterpret_cast(&vkDestroyDeferredOperationKHR); + } else + if (std::strcmp(pName, "vkGetDeferredOperationMaxConcurrencyKHR") == 0) { + return reinterpret_cast(&vkGetDeferredOperationMaxConcurrencyKHR); + } else + if (std::strcmp(pName, "vkGetDeferredOperationResultKHR") == 0) { + return reinterpret_cast(&vkGetDeferredOperationResultKHR); + } else + if (std::strcmp(pName, "vkDeferredOperationJoinKHR") == 0) { + return reinterpret_cast(&vkDeferredOperationJoinKHR); + } else + if (std::strcmp(pName, "vkCmdSetCullMode") == 0) { + return reinterpret_cast(&vkCmdSetCullMode); + } else + if (std::strcmp(pName, "vkCmdSetCullModeEXT") == 0) { + return reinterpret_cast(&vkCmdSetCullMode); + } else + if (std::strcmp(pName, "vkCmdSetFrontFace") == 0) { + return reinterpret_cast(&vkCmdSetFrontFace); + } else + if (std::strcmp(pName, "vkCmdSetFrontFaceEXT") == 0) { + return reinterpret_cast(&vkCmdSetFrontFace); + } else + if (std::strcmp(pName, "vkCmdSetPrimitiveTopology") == 0) { + return reinterpret_cast(&vkCmdSetPrimitiveTopology); + } else + if (std::strcmp(pName, "vkCmdSetPrimitiveTopologyEXT") == 0) { + return reinterpret_cast(&vkCmdSetPrimitiveTopology); + } else + if (std::strcmp(pName, "vkCmdSetViewportWithCount") == 0) { + return reinterpret_cast(&vkCmdSetViewportWithCount); + } else + if (std::strcmp(pName, "vkCmdSetViewportWithCountEXT") == 0) { + return reinterpret_cast(&vkCmdSetViewportWithCount); + } else + if (std::strcmp(pName, "vkCmdSetScissorWithCount") == 0) { + return reinterpret_cast(&vkCmdSetScissorWithCount); + } else + if (std::strcmp(pName, "vkCmdSetScissorWithCountEXT") == 0) { + return reinterpret_cast(&vkCmdSetScissorWithCount); + } else + if (std::strcmp(pName, "vkCmdBindVertexBuffers2") == 0) { + return reinterpret_cast(&vkCmdBindVertexBuffers2); + } else + if (std::strcmp(pName, "vkCmdBindVertexBuffers2EXT") == 0) { + return reinterpret_cast(&vkCmdBindVertexBuffers2); + } else + if (std::strcmp(pName, "vkCmdSetDepthTestEnable") == 0) { + return reinterpret_cast(&vkCmdSetDepthTestEnable); + } else + if (std::strcmp(pName, "vkCmdSetDepthTestEnableEXT") == 0) { + return reinterpret_cast(&vkCmdSetDepthTestEnable); + } else + if (std::strcmp(pName, "vkCmdSetDepthWriteEnable") == 0) { + return reinterpret_cast(&vkCmdSetDepthWriteEnable); + } else + if (std::strcmp(pName, "vkCmdSetDepthWriteEnableEXT") == 0) { + return reinterpret_cast(&vkCmdSetDepthWriteEnable); + } else + if (std::strcmp(pName, "vkCmdSetDepthCompareOp") == 0) { + return reinterpret_cast(&vkCmdSetDepthCompareOp); + } else + if (std::strcmp(pName, "vkCmdSetDepthCompareOpEXT") == 0) { + return reinterpret_cast(&vkCmdSetDepthCompareOp); + } else + if (std::strcmp(pName, "vkCmdSetDepthBoundsTestEnable") == 0) { + return reinterpret_cast(&vkCmdSetDepthBoundsTestEnable); + } else + if (std::strcmp(pName, "vkCmdSetDepthBoundsTestEnableEXT") == 0) { + return reinterpret_cast(&vkCmdSetDepthBoundsTestEnable); + } else + if (std::strcmp(pName, "vkCmdSetStencilTestEnable") == 0) { + return reinterpret_cast(&vkCmdSetStencilTestEnable); + } else + if (std::strcmp(pName, "vkCmdSetStencilTestEnableEXT") == 0) { + return reinterpret_cast(&vkCmdSetStencilTestEnable); + } else + if (std::strcmp(pName, "vkCmdSetStencilOp") == 0) { + return reinterpret_cast(&vkCmdSetStencilOp); + } else + if (std::strcmp(pName, "vkCmdSetStencilOpEXT") == 0) { + return reinterpret_cast(&vkCmdSetStencilOp); + } else + if (std::strcmp(pName, "vkCmdSetPatchControlPointsEXT") == 0) { + return reinterpret_cast(&vkCmdSetPatchControlPointsEXT); + } else + if (std::strcmp(pName, "vkCmdSetRasterizerDiscardEnable") == 0) { + return reinterpret_cast(&vkCmdSetRasterizerDiscardEnable); + } else + if (std::strcmp(pName, "vkCmdSetRasterizerDiscardEnableEXT") == 0) { + return reinterpret_cast(&vkCmdSetRasterizerDiscardEnable); + } else + if (std::strcmp(pName, "vkCmdSetDepthBiasEnable") == 0) { + return reinterpret_cast(&vkCmdSetDepthBiasEnable); + } else + if (std::strcmp(pName, "vkCmdSetDepthBiasEnableEXT") == 0) { + return reinterpret_cast(&vkCmdSetDepthBiasEnable); + } else + if (std::strcmp(pName, "vkCmdSetLogicOpEXT") == 0) { + return reinterpret_cast(&vkCmdSetLogicOpEXT); + } else + if (std::strcmp(pName, "vkCmdSetPrimitiveRestartEnable") == 0) { + return reinterpret_cast(&vkCmdSetPrimitiveRestartEnable); + } else + if (std::strcmp(pName, "vkCmdSetPrimitiveRestartEnableEXT") == 0) { + return reinterpret_cast(&vkCmdSetPrimitiveRestartEnable); + } else + if (std::strcmp(pName, "vkCreatePrivateDataSlot") == 0) { + return reinterpret_cast(&vkCreatePrivateDataSlot); + } else + if (std::strcmp(pName, "vkCreatePrivateDataSlotEXT") == 0) { + return reinterpret_cast(&vkCreatePrivateDataSlot); + } else + if (std::strcmp(pName, "vkDestroyPrivateDataSlot") == 0) { + return reinterpret_cast(&vkDestroyPrivateDataSlot); + } else + if (std::strcmp(pName, "vkDestroyPrivateDataSlotEXT") == 0) { + return reinterpret_cast(&vkDestroyPrivateDataSlot); + } else + if (std::strcmp(pName, "vkSetPrivateData") == 0) { + return reinterpret_cast(&vkSetPrivateData); + } else + if (std::strcmp(pName, "vkSetPrivateDataEXT") == 0) { + return reinterpret_cast(&vkSetPrivateData); + } else + if (std::strcmp(pName, "vkGetPrivateData") == 0) { + return reinterpret_cast(&vkGetPrivateData); + } else + if (std::strcmp(pName, "vkGetPrivateDataEXT") == 0) { + return reinterpret_cast(&vkGetPrivateData); + } else + if (std::strcmp(pName, "vkCmdCopyBuffer2") == 0) { + return reinterpret_cast(&vkCmdCopyBuffer2); + } else + if (std::strcmp(pName, "vkCmdCopyBuffer2KHR") == 0) { + return reinterpret_cast(&vkCmdCopyBuffer2); + } else + if (std::strcmp(pName, "vkCmdCopyImage2") == 0) { + return reinterpret_cast(&vkCmdCopyImage2); + } else + if (std::strcmp(pName, "vkCmdCopyImage2KHR") == 0) { + return reinterpret_cast(&vkCmdCopyImage2); + } else + if (std::strcmp(pName, "vkCmdBlitImage2") == 0) { + return reinterpret_cast(&vkCmdBlitImage2); + } else + if (std::strcmp(pName, "vkCmdBlitImage2KHR") == 0) { + return reinterpret_cast(&vkCmdBlitImage2); + } else + if (std::strcmp(pName, "vkCmdCopyBufferToImage2") == 0) { + return reinterpret_cast(&vkCmdCopyBufferToImage2); + } else + if (std::strcmp(pName, "vkCmdCopyBufferToImage2KHR") == 0) { + return reinterpret_cast(&vkCmdCopyBufferToImage2); + } else + if (std::strcmp(pName, "vkCmdCopyImageToBuffer2") == 0) { + return reinterpret_cast(&vkCmdCopyImageToBuffer2); + } else + if (std::strcmp(pName, "vkCmdCopyImageToBuffer2KHR") == 0) { + return reinterpret_cast(&vkCmdCopyImageToBuffer2); + } else + if (std::strcmp(pName, "vkCmdResolveImage2") == 0) { + return reinterpret_cast(&vkCmdResolveImage2); + } else + if (std::strcmp(pName, "vkCmdResolveImage2KHR") == 0) { + return reinterpret_cast(&vkCmdResolveImage2); + } else + if (std::strcmp(pName, "vkCmdSetFragmentShadingRateKHR") == 0) { + return reinterpret_cast(&vkCmdSetFragmentShadingRateKHR); + } else + if (std::strcmp(pName, "vkCmdSetFragmentShadingRateEnumNV") == 0) { + return reinterpret_cast(&vkCmdSetFragmentShadingRateEnumNV); + } else + if (std::strcmp(pName, "vkGetAccelerationStructureBuildSizesKHR") == 0) { + return reinterpret_cast(&vkGetAccelerationStructureBuildSizesKHR); + } else + if (std::strcmp(pName, "vkCmdSetVertexInputEXT") == 0) { + return reinterpret_cast(&vkCmdSetVertexInputEXT); + } else + if (std::strcmp(pName, "vkCmdSetColorWriteEnableEXT") == 0) { + return reinterpret_cast(&vkCmdSetColorWriteEnableEXT); + } else + if (std::strcmp(pName, "vkCmdSetEvent2") == 0) { + return reinterpret_cast(&vkCmdSetEvent2); + } else + if (std::strcmp(pName, "vkCmdSetEvent2KHR") == 0) { + return reinterpret_cast(&vkCmdSetEvent2); + } else + if (std::strcmp(pName, "vkCmdResetEvent2") == 0) { + return reinterpret_cast(&vkCmdResetEvent2); + } else + if (std::strcmp(pName, "vkCmdResetEvent2KHR") == 0) { + return reinterpret_cast(&vkCmdResetEvent2); + } else + if (std::strcmp(pName, "vkCmdWaitEvents2") == 0) { + return reinterpret_cast(&vkCmdWaitEvents2); + } else + if (std::strcmp(pName, "vkCmdWaitEvents2KHR") == 0) { + return reinterpret_cast(&vkCmdWaitEvents2); + } else + if (std::strcmp(pName, "vkCmdPipelineBarrier2") == 0) { + return reinterpret_cast(&vkCmdPipelineBarrier2); + } else + if (std::strcmp(pName, "vkCmdPipelineBarrier2KHR") == 0) { + return reinterpret_cast(&vkCmdPipelineBarrier2); + } else + if (std::strcmp(pName, "vkQueueSubmit2") == 0) { + return reinterpret_cast(&vkQueueSubmit2); + } else + if (std::strcmp(pName, "vkQueueSubmit2KHR") == 0) { + return reinterpret_cast(&vkQueueSubmit2); + } else + if (std::strcmp(pName, "vkCmdWriteTimestamp2") == 0) { + return reinterpret_cast(&vkCmdWriteTimestamp2); + } else + if (std::strcmp(pName, "vkCmdWriteTimestamp2KHR") == 0) { + return reinterpret_cast(&vkCmdWriteTimestamp2); + } else + if (std::strcmp(pName, "vkCmdWriteBufferMarker2AMD") == 0) { + return reinterpret_cast(&vkCmdWriteBufferMarker2AMD); + } else + if (std::strcmp(pName, "vkGetQueueCheckpointData2NV") == 0) { + return reinterpret_cast(&vkGetQueueCheckpointData2NV); + } else + if (std::strcmp(pName, "vkCreateCuModuleNVX") == 0) { + return reinterpret_cast(&vkCreateCuModuleNVX); + } else + if (std::strcmp(pName, "vkCreateCuFunctionNVX") == 0) { + return reinterpret_cast(&vkCreateCuFunctionNVX); + } else + if (std::strcmp(pName, "vkDestroyCuModuleNVX") == 0) { + return reinterpret_cast(&vkDestroyCuModuleNVX); + } else + if (std::strcmp(pName, "vkDestroyCuFunctionNVX") == 0) { + return reinterpret_cast(&vkDestroyCuFunctionNVX); + } else + if (std::strcmp(pName, "vkCmdCuLaunchKernelNVX") == 0) { + return reinterpret_cast(&vkCmdCuLaunchKernelNVX); + } else + if (std::strcmp(pName, "vkSetDeviceMemoryPriorityEXT") == 0) { + return reinterpret_cast(&vkSetDeviceMemoryPriorityEXT); + } else + if (std::strcmp(pName, "vkWaitForPresentKHR") == 0) { + return reinterpret_cast(&vkWaitForPresentKHR); + } else + if (std::strcmp(pName, "vkCmdBeginRendering") == 0) { + return reinterpret_cast(&vkCmdBeginRendering); + } else + if (std::strcmp(pName, "vkCmdBeginRenderingKHR") == 0) { + return reinterpret_cast(&vkCmdBeginRendering); + } else + if (std::strcmp(pName, "vkCmdEndRendering") == 0) { + return reinterpret_cast(&vkCmdEndRendering); + } else + if (std::strcmp(pName, "vkCmdEndRenderingKHR") == 0) { + return reinterpret_cast(&vkCmdEndRendering); + } else + if (std::strcmp(pName, "vkGetDescriptorSetLayoutHostMappingInfoVALVE") == 0) { + return reinterpret_cast(&vkGetDescriptorSetLayoutHostMappingInfoVALVE); + } else + if (std::strcmp(pName, "vkGetDescriptorSetHostMappingVALVE") == 0) { + return reinterpret_cast(&vkGetDescriptorSetHostMappingVALVE); + } else + if (std::strcmp(pName, "vkGetImageSubresourceLayout2EXT") == 0) { + return reinterpret_cast(&vkGetImageSubresourceLayout2EXT); + } else + if (std::strcmp(pName, "vkGetPipelinePropertiesEXT") == 0) { + return reinterpret_cast(&vkGetPipelinePropertiesEXT); + } else +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + + if (std::strcmp(pName, "vkGetSwapchainGrallocUsageANDROID") == 0) { + return reinterpret_cast(&vkGetSwapchainGrallocUsageANDROID); + } else + if (std::strcmp(pName, "vkGetSwapchainGrallocUsage2ANDROID") == 0) { + return reinterpret_cast(&vkGetSwapchainGrallocUsage2ANDROID); + } else + if (std::strcmp(pName, "vkAcquireImageANDROID") == 0) { + return reinterpret_cast(&vkAcquireImageANDROID); + } else + if (std::strcmp(pName, "vkQueueSignalReleaseImageANDROID") == 0) { + return reinterpret_cast(&vkQueueSignalReleaseImageANDROID); + } else + if (std::strcmp(pName, "vkGetAndroidHardwareBufferPropertiesANDROID") == 0) { + return reinterpret_cast(&vkGetAndroidHardwareBufferPropertiesANDROID); + } else + if (std::strcmp(pName, "vkGetMemoryAndroidHardwareBufferANDROID") == 0) { + return reinterpret_cast(&vkGetMemoryAndroidHardwareBufferANDROID); + } else +#endif // defined(VK_USE_PLATFORM_ANDROID_KHR) + +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) + +#endif // defined(VK_USE_PLATFORM_DIRECTFB_EXT) + +#if defined(VK_USE_PLATFORM_FUCHSIA) + + if (std::strcmp(pName, "vkGetMemoryZirconHandleFUCHSIA") == 0) { + return reinterpret_cast(&vkGetMemoryZirconHandleFUCHSIA); + } else + if (std::strcmp(pName, "vkGetMemoryZirconHandlePropertiesFUCHSIA") == 0) { + return reinterpret_cast(&vkGetMemoryZirconHandlePropertiesFUCHSIA); + } else + if (std::strcmp(pName, "vkGetSemaphoreZirconHandleFUCHSIA") == 0) { + return reinterpret_cast(&vkGetSemaphoreZirconHandleFUCHSIA); + } else + if (std::strcmp(pName, "vkImportSemaphoreZirconHandleFUCHSIA") == 0) { + return reinterpret_cast(&vkImportSemaphoreZirconHandleFUCHSIA); + } else + if (std::strcmp(pName, "vkCreateBufferCollectionFUCHSIA") == 0) { + return reinterpret_cast(&vkCreateBufferCollectionFUCHSIA); + } else + if (std::strcmp(pName, "vkSetBufferCollectionBufferConstraintsFUCHSIA") == 0) { + return reinterpret_cast(&vkSetBufferCollectionBufferConstraintsFUCHSIA); + } else + if (std::strcmp(pName, "vkSetBufferCollectionImageConstraintsFUCHSIA") == 0) { + return reinterpret_cast(&vkSetBufferCollectionImageConstraintsFUCHSIA); + } else + if (std::strcmp(pName, "vkDestroyBufferCollectionFUCHSIA") == 0) { + return reinterpret_cast(&vkDestroyBufferCollectionFUCHSIA); + } else + if (std::strcmp(pName, "vkGetBufferCollectionPropertiesFUCHSIA") == 0) { + return reinterpret_cast(&vkGetBufferCollectionPropertiesFUCHSIA); + } else +#endif // defined(VK_USE_PLATFORM_FUCHSIA) + +#if defined(VK_USE_PLATFORM_GGP) + +#endif // defined(VK_USE_PLATFORM_GGP) + +#if defined(VK_USE_PLATFORM_IOS_MVK) + +#endif // defined(VK_USE_PLATFORM_IOS_MVK) + +#if defined(VK_USE_PLATFORM_MACOS_MVK) + +#endif // defined(VK_USE_PLATFORM_MACOS_MVK) + +#if defined(VK_USE_PLATFORM_METAL_EXT) + + if (std::strcmp(pName, "vkExportMetalObjectsEXT") == 0) { + return reinterpret_cast(&vkExportMetalObjectsEXT); + } else +#endif // defined(VK_USE_PLATFORM_METAL_EXT) + +#if defined(VK_ENABLE_BETA_EXTENSIONS) + + if (std::strcmp(pName, "vkCreateVideoSessionKHR") == 0) { + return reinterpret_cast(&vkCreateVideoSessionKHR); + } else + if (std::strcmp(pName, "vkDestroyVideoSessionKHR") == 0) { + return reinterpret_cast(&vkDestroyVideoSessionKHR); + } else + if (std::strcmp(pName, "vkCreateVideoSessionParametersKHR") == 0) { + return reinterpret_cast(&vkCreateVideoSessionParametersKHR); + } else + if (std::strcmp(pName, "vkUpdateVideoSessionParametersKHR") == 0) { + return reinterpret_cast(&vkUpdateVideoSessionParametersKHR); + } else + if (std::strcmp(pName, "vkDestroyVideoSessionParametersKHR") == 0) { + return reinterpret_cast(&vkDestroyVideoSessionParametersKHR); + } else + if (std::strcmp(pName, "vkGetVideoSessionMemoryRequirementsKHR") == 0) { + return reinterpret_cast(&vkGetVideoSessionMemoryRequirementsKHR); + } else + if (std::strcmp(pName, "vkBindVideoSessionMemoryKHR") == 0) { + return reinterpret_cast(&vkBindVideoSessionMemoryKHR); + } else + if (std::strcmp(pName, "vkCmdDecodeVideoKHR") == 0) { + return reinterpret_cast(&vkCmdDecodeVideoKHR); + } else + if (std::strcmp(pName, "vkCmdBeginVideoCodingKHR") == 0) { + return reinterpret_cast(&vkCmdBeginVideoCodingKHR); + } else + if (std::strcmp(pName, "vkCmdControlVideoCodingKHR") == 0) { + return reinterpret_cast(&vkCmdControlVideoCodingKHR); + } else + if (std::strcmp(pName, "vkCmdEndVideoCodingKHR") == 0) { + return reinterpret_cast(&vkCmdEndVideoCodingKHR); + } else + if (std::strcmp(pName, "vkCmdEncodeVideoKHR") == 0) { + return reinterpret_cast(&vkCmdEncodeVideoKHR); + } else +#endif // defined(VK_ENABLE_BETA_EXTENSIONS) + +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + +#endif // defined(VK_USE_PLATFORM_SCREEN_QNX) + +#if defined(VK_USE_PLATFORM_VI_NN) + +#endif // defined(VK_USE_PLATFORM_VI_NN) + +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + +#endif // defined(VK_USE_PLATFORM_WAYLAND_KHR) + +#if defined(VK_USE_PLATFORM_WIN32_KHR) + + if (std::strcmp(pName, "vkGetMemoryWin32HandleNV") == 0) { + return reinterpret_cast(&vkGetMemoryWin32HandleNV); + } else + if (std::strcmp(pName, "vkGetMemoryWin32HandleKHR") == 0) { + return reinterpret_cast(&vkGetMemoryWin32HandleKHR); + } else + if (std::strcmp(pName, "vkGetMemoryWin32HandlePropertiesKHR") == 0) { + return reinterpret_cast(&vkGetMemoryWin32HandlePropertiesKHR); + } else + if (std::strcmp(pName, "vkGetSemaphoreWin32HandleKHR") == 0) { + return reinterpret_cast(&vkGetSemaphoreWin32HandleKHR); + } else + if (std::strcmp(pName, "vkImportSemaphoreWin32HandleKHR") == 0) { + return reinterpret_cast(&vkImportSemaphoreWin32HandleKHR); + } else + if (std::strcmp(pName, "vkGetFenceWin32HandleKHR") == 0) { + return reinterpret_cast(&vkGetFenceWin32HandleKHR); + } else + if (std::strcmp(pName, "vkImportFenceWin32HandleKHR") == 0) { + return reinterpret_cast(&vkImportFenceWin32HandleKHR); + } else + if (std::strcmp(pName, "vkAcquireFullScreenExclusiveModeEXT") == 0) { + return reinterpret_cast(&vkAcquireFullScreenExclusiveModeEXT); + } else + if (std::strcmp(pName, "vkReleaseFullScreenExclusiveModeEXT") == 0) { + return reinterpret_cast(&vkReleaseFullScreenExclusiveModeEXT); + } else +#endif // defined(VK_USE_PLATFORM_WIN32_KHR) + +#if defined(VK_USE_PLATFORM_XCB_KHR) + +#endif // defined(VK_USE_PLATFORM_XCB_KHR) + +#if defined(VK_USE_PLATFORM_XLIB_KHR) + +#endif // defined(VK_USE_PLATFORM_XLIB_KHR) + +#if defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) + +#endif // defined(VK_USE_PLATFORM_XLIB_XRANDR_EXT) + + {{ + return nullptr; + }} +} +} // namespace vk_capture diff --git a/source/functions.hpp b/source/functions.hpp new file mode 100644 index 0000000..77d3287 --- /dev/null +++ b/source/functions.hpp @@ -0,0 +1,14 @@ + +#pragma once + +#if !defined(VK_CAPTURE_FUNCTIONS_HPP_INCLUDED) +#define VK_CAPTURE_FUNCTIONS_HPP_INCLUDED 1 + +#include + +namespace vk_capture +{ +PFN_vkVoidFunction getWrappedFunctionPtr(const char* pName); +} // namespace vk_capture + +#endif // VK_CAPTURE_FUNCTIONS_HPP_INCLUDED diff --git a/source/layer.cpp b/source/layer.cpp new file mode 100644 index 0000000..26dec5b --- /dev/null +++ b/source/layer.cpp @@ -0,0 +1,164 @@ + +#include +#include +#include +#include +#include "dispatch_table.hpp" +#include "functions.hpp" +#include "record_list.hpp" +#include "vk_capture.h" + +namespace vk_capture +{ +inline constexpr std::uint32_t LOADER_LAYER_VERSION = 2; + +PFN_vkVoidFunction getLayerFunctionPtr(const char* pName); + +VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) +{ + const VkLayerInstanceCreateInfo* layerCreateInfo = static_cast(pCreateInfo->pNext); + + // step through the chain of pNext until we get to the link info + while(layerCreateInfo && (layerCreateInfo->sType != VK_STRUCTURE_TYPE_LOADER_INSTANCE_CREATE_INFO || + layerCreateInfo->function != VK_LAYER_LINK_INFO)) + { + layerCreateInfo = static_cast(layerCreateInfo->pNext); + } + + if(layerCreateInfo == nullptr) + { + // No loader instance create info + return VK_ERROR_INITIALIZATION_FAILED; + } + + PFN_vkGetInstanceProcAddr gpa = layerCreateInfo->u.pLayerInfo->pfnNextGetInstanceProcAddr; + // move chain on for next layer + const_cast(layerCreateInfo)->u.pLayerInfo = layerCreateInfo->u.pLayerInfo->pNext; + + PFN_vkCreateInstance createFunc = reinterpret_cast(gpa(VK_NULL_HANDLE, "vkCreateInstance")); + + VkResult ret = createFunc(pCreateInfo, pAllocator, pInstance); + if (ret != VK_SUCCESS) + { + return ret; + } + + // fetch our own dispatch table for the functions we need, into the next layer + layer_init_instance_dispatch_table(*pInstance, &vk_capture::g_instanceDispatchTable, gpa); + + return VK_SUCCESS; +} + +VkResult vkCreateDevice( + VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDevice* pDevice) +{ + const VkLayerDeviceCreateInfo* layerCreateInfo = static_cast(pCreateInfo->pNext); + + // step through the chain of pNext until we get to the link info + while(layerCreateInfo && (layerCreateInfo->sType != VK_STRUCTURE_TYPE_LOADER_DEVICE_CREATE_INFO || + layerCreateInfo->function != VK_LAYER_LINK_INFO)) + { + layerCreateInfo = static_cast(layerCreateInfo->pNext); + } + + if(layerCreateInfo == nullptr) + { + // No loader instance create info + return VK_ERROR_INITIALIZATION_FAILED; + } + + PFN_vkGetInstanceProcAddr gipa = layerCreateInfo->u.pLayerInfo->pfnNextGetInstanceProcAddr; + PFN_vkGetDeviceProcAddr gdpa = layerCreateInfo->u.pLayerInfo->pfnNextGetDeviceProcAddr; + // move chain on for next layer + const_cast(layerCreateInfo)->u.pLayerInfo = layerCreateInfo->u.pLayerInfo->pNext; + + PFN_vkCreateDevice createFunc = (PFN_vkCreateDevice)gipa(VK_NULL_HANDLE, "vkCreateDevice"); + + VkResult ret = createFunc(physicalDevice, pCreateInfo, pAllocator, pDevice); + + if (ret != VK_SUCCESS) + { + return ret; + } + layer_init_device_dispatch_table(*pDevice, &vk_capture::g_dispatchTable, gdpa); + + return VK_SUCCESS; +} + +PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName) +{ + PFN_vkVoidFunction ptr = getLayerFunctionPtr(pName); + if (ptr) { + return ptr; + } + else { + return g_dispatchTable.GetDeviceProcAddr(device, pName); + } +} + +PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName) +{ + PFN_vkVoidFunction ptr = getLayerFunctionPtr(pName); + if (ptr) { + return ptr; + } + else { + return g_instanceDispatchTable.GetInstanceProcAddr(instance, pName); + } +} + +PFN_vkVoidFunction getLayerFunctionPtr(const char* pName) +{ + if (std::strcmp(pName, "vkCreateInstance") == 0) { + return reinterpret_cast(&vk_capture::vkCreateInstance); + } + else if (std::strcmp(pName, "vkCreateDevice") == 0) { + return reinterpret_cast(&vk_capture::vkCreateDevice); + } + else if (std::strcmp(pName, "vkGetInstanceProcAddr") == 0) { + return reinterpret_cast(&vk_capture::vkGetInstanceProcAddr); + } + if (std::strcmp(pName, "vkGetDeviceProcAddr") == 0) { + return reinterpret_cast(&vkGetDeviceProcAddr); + } + else if (std::strcmp(pName, "vkAllocateRecordListMWN") == 0) { + return reinterpret_cast(&vkAllocateRecordListMWN); + } + else if (std::strcmp(pName, "vkFreeRecordListMWN") == 0) { + return reinterpret_cast(&vkFreeRecordListMWN); + } + else if (std::strcmp(pName, "vkBeginRecordingMWN") == 0) { + return reinterpret_cast(&vkBeginRecordingMWN); + } + else if (std::strcmp(pName, "vkEndRecordingMWN") == 0) { + return reinterpret_cast(&vkEndRecordingMWN); + } + else if (std::strcmp(pName, "vkGetRecordListItemsMWN") == 0) { + return reinterpret_cast(&vkGetRecordListItemsMWN); + } + else { + return getWrappedFunctionPtr(pName); + } +} +} // namespace vk_capture + +extern "C" +{ + +VK_LAYER_EXPORT VkResult VKAPI_CALL vk_capture_vkNegotiateLoaderLayerInterfaceVersion(VkNegotiateLayerInterface* pVersionStruct) +{ + if (pVersionStruct->loaderLayerInterfaceVersion < vk_capture::LOADER_LAYER_VERSION) { + return VK_ERROR_INITIALIZATION_FAILED; + } + pVersionStruct->sType = LAYER_NEGOTIATE_INTERFACE_STRUCT; + pVersionStruct->pNext = nullptr; + pVersionStruct->loaderLayerInterfaceVersion = vk_capture::LOADER_LAYER_VERSION; + pVersionStruct->pfnGetInstanceProcAddr = &vk_capture::vkGetInstanceProcAddr; + pVersionStruct->pfnGetDeviceProcAddr = &vk_capture::vkGetDeviceProcAddr; + pVersionStruct->pfnGetPhysicalDeviceProcAddr = nullptr; + return VK_SUCCESS; +} +} // extern "C" diff --git a/source/record_list.cpp b/source/record_list.cpp new file mode 100644 index 0000000..e651340 --- /dev/null +++ b/source/record_list.cpp @@ -0,0 +1,94 @@ + +#include "record_list.hpp" + +#include +#include + +namespace vk_capture +{ + +// +// internal defines +// + +// +// internal constants +// + +// +// internal types +// + +// +// internal variables +// + +// +// internal functions +// + +// +// public variables +// + +VkRecordListMWN g_activeRecordList = nullptr; // TODO: per device and or per thread? + +// +// public functions +// + +VkResult vkAllocateRecordListMWN(VkDevice /* device */, const VkRecordListAllocateInfoMWN* pAllocInfo, VkRecordListMWN* pRecordList) +{ + (void) pAllocInfo; + + VkRecordListMWN result = new VkRecordListMWN_T(); // TODO: use Vulkan allocators + if (result == nullptr) { + return VK_ERROR_OUT_OF_HOST_MEMORY; + } + *pRecordList = result; + return VK_SUCCESS; +} + +void vkFreeRecordListMWN(VkDevice /* device */, VkRecordListMWN recordList) +{ + assert(recordList != g_activeRecordList); + delete recordList; // TODO: allocators +} + +VkResult vkBeginRecordingMWN(VkDevice /* device */, const VkRecordInfoMWN* pRecordInfo) +{ + assert(g_activeRecordList == nullptr); + assert(pRecordInfo && pRecordInfo->recordList); + g_activeRecordList = pRecordInfo->recordList; + return VK_SUCCESS; +} + +void vkEndRecordingMWN(VkDevice /* device */) +{ + assert(g_activeRecordList != nullptr); + g_activeRecordList = nullptr; +} + +VkResult vkGetRecordListItemsMWN(VkDevice /* device */, VkRecordListMWN recordList, uint32_t* pItemCount, VkRecordListItemMWN** pItems) +{ + assert(pItemCount); + assert(pItems); + + *pItemCount = static_cast(recordList->items.size()); + *pItems = recordList->items.data(); + return VK_SUCCESS; +} + +VkVariantMWN* allocVariant(std::size_t num) +{ + assert(g_activeRecordList); + return g_activeRecordList->values.allocate(num); +} + +void* allocData(std::size_t bytes, std::size_t alignment) +{ + assert(g_activeRecordList); + return g_activeRecordList->data.allocate(bytes, alignment); +} + +} // namespace vk_capture diff --git a/source/record_list.hpp b/source/record_list.hpp new file mode 100644 index 0000000..fd00c54 --- /dev/null +++ b/source/record_list.hpp @@ -0,0 +1,87 @@ + +#pragma once + +#if !defined(VK_CAPTURE_RECORD_LIST_HPP_INCLUDED) +#define VK_CAPTURE_RECORD_LIST_HPP_INCLUDED 1 + +#include +#include +#include "data_pool.hpp" +#include "variant_pool.hpp" +#include "vk_capture.h" +#include "vk_function_ids.h" + +typedef struct VkRecordListMWN_T { + std::vector items; // TODO: use Vulkan allocators + vk_capture::VariantPool values; + vk_capture::DataPool data; +} VkRecordListMWN_T; + +namespace vk_capture +{ + +// +// public defines +// + +// +// public constants +// + +// +// public types +// + +// +// public variables +// + +extern VkRecordListMWN g_activeRecordList; + +// +// public functions +// + +VkResult vkAllocateRecordListMWN(VkDevice device, const VkRecordListAllocateInfoMWN* pAllocInfo, VkRecordListMWN* pRecordList); +void vkFreeRecordListMWN(VkDevice device, VkRecordListMWN recordList); +VkResult vkBeginRecordingMWN(VkDevice device, const VkRecordInfoMWN* pRecordInfo); +void vkEndRecordingMWN(VkDevice device); +VkResult vkGetRecordListItemsMWN(VkDevice device, VkRecordListMWN recordList, uint32_t* pItemCount, VkRecordListItemMWN** pItems); + +template +void recordFunction(VkFunctionMWN function, const TResult& result, const TArgs&... args) +{ + (void) result; + if (!g_activeRecordList) { + return; + } + + VkRecordListItemMWN& item = g_activeRecordList->items.emplace_back(); + item.function = function; + item.numParameters = static_cast(sizeof...(TArgs)); + item.pParameterValues = g_activeRecordList->values.allocate(sizeof...(TArgs)); + variantWrap(result, item.returnValue); + + VkVariantMWN* variant = item.pParameterValues; + (variantWrap(args, *(variant++)), ...); +} + +template +void recordVoidFunction(VkFunctionMWN function, const TArgs&... args) +{ + if (!g_activeRecordList) { + return; + } + + VkRecordListItemMWN& item = g_activeRecordList->items.emplace_back(); + item.function = function; + item.numParameters = static_cast(sizeof...(TArgs)); + item.pParameterValues = g_activeRecordList->values.allocate(sizeof...(TArgs)); + item.returnValue.type = VK_VARIANT_TYPE_NONE_MWN; + + VkVariantMWN* variant = item.pParameterValues; + (variantWrap(args, *(variant++)), ...); +} +} // namespace vk_capture + +#endif // !defined(VK_CAPTURE_RECORD_LIST_HPP_INCLUDED) diff --git a/source/variant_pool.cpp b/source/variant_pool.cpp new file mode 100644 index 0000000..1bcdc6a --- /dev/null +++ b/source/variant_pool.cpp @@ -0,0 +1,50 @@ + +#include "variant_pool.hpp" + +#include + +namespace vk_capture +{ + +// +// internal defines +// + +// +// internal constants +// + +// +// internal types +// + +// +// internal variables +// + +// +// internal functions +// + +// +// public functions +// + +VkVariantMWN* VariantPool::allocate(std::size_t num) +{ + assert(num > 0 && num <= PAGE_SIZE); + const std::size_t remainingOnPage = PAGE_SIZE - (nextIndex % PAGE_SIZE); + if (remainingOnPage == PAGE_SIZE || remainingOnPage < num) + { + // next page + pages.push_back(std::make_unique()); + nextIndex = PAGE_SIZE * (pages.size() - 1); + } + const std::size_t page = nextIndex / PAGE_SIZE; + const std::size_t localIndex = nextIndex % PAGE_SIZE; + VkVariantMWN* result = &(*pages[page])[localIndex]; + nextIndex += num; + return result; +} + +} // namespace v diff --git a/source/variant_pool.hpp b/source/variant_pool.hpp new file mode 100644 index 0000000..01ea85b --- /dev/null +++ b/source/variant_pool.hpp @@ -0,0 +1,146 @@ + +#pragma once + +#if !defined(VK_CAPTURE_VARIANT_POOL_HPP_INCLUDED) +#define VK_CAPTURE_VARIANT_POOL_HPP_INCLUDED 1 + +#include +#include +#include +#include +#include "common.hpp" +#include "variant_wrap.hpp" +#include "vk_capture.h" + +namespace vk_capture +{ + +// +// public defines +// + +// +// public constants +// + +// +// public types +// + +struct VariantPool +{ + static constexpr std::size_t PAGE_SIZE = 1024; + using page_t = std::array; + using page_ptr_t = std::unique_ptr; + + std::vector pages; + std::size_t nextIndex = 0; + + VkVariantMWN* allocate(std::size_t num = 1); + inline void reset() { nextIndex = 0; } +}; + +// +// public functions +// + +template +inline void variantWrap(const TValue& /* value */, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_UNKNOWN_MWN; +} + +inline void variantWrap(bool value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_BOOL_MWN; + outVariant.uintValue = value; +} + +inline void variantWrap(std::uint8_t value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_UINT8_MWN; + outVariant.uintValue = value; +} + +inline void variantWrap(std::int8_t value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_INT8_MWN; + outVariant.intValue = value; +} + +inline void variantWrap(std::uint16_t value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_UINT16_MWN; + outVariant.uintValue = value; +} + +inline void variantWrap(std::int16_t value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_INT16_MWN; + outVariant.intValue = value; +} + +inline void variantWrap(std::uint32_t value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_UINT32_MWN; + outVariant.uintValue = value; +} + +inline void variantWrap(std::int32_t value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_INT32_MWN; + outVariant.intValue = value; +} + +inline void variantWrap(std::uint64_t value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_UINT64_MWN; + outVariant.uintValue = value; +} + +inline void variantWrap(std::int64_t value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_INT64_MWN; + outVariant.intValue = value; +} + +inline void variantWrap(const void* value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_VOID_POINTER_MWN; + outVariant.voidPointerValue = value; +} + +template +inline void variantWrap(const TPointed* value, VkVariantMWN& outVariant); + +template +inline void variantWrap(const TEle (&value)[count], VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_ARRAY_MWN; + outVariant.arrayValue.numElements = count; + outVariant.arrayValue.elements = allocVariant(count); + + for (std::size_t idx = 0; idx < count; ++idx) { + variantWrap(value[idx], outVariant.arrayValue.elements[idx]); + } +} + +template +inline void variantWrap(const TPointed* value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_POINTER_MWN; + if (value != nullptr) + { + outVariant.pointerValue = allocVariant(1); + variantWrap(*value, *outVariant.pointerValue); + } + else + { + // TODO: now the type is missing ... + outVariant.pointerValue = nullptr; + } +} + +} // namespace vk_capture + +#endif // !defined(VK_CAPTURE_VARIANT_POOL_HPP_INCLUDED) diff --git a/source/variant_wrap.hpp b/source/variant_wrap.hpp new file mode 100644 index 0000000..d3b40d7 --- /dev/null +++ b/source/variant_wrap.hpp @@ -0,0 +1,19673 @@ + +// This file has been automatically generated. Do NOT edit edit manually, all your changes will be lost when it is regenerated. + +#pragma once + +#if !defined(VK_CAPTURE_VARIANT_WRAP_HPP_INCLUDED) +#define VK_CAPTURE_VARIANT_WRAP_HPP_INCLUDED 1 + +#include +#include +#include +#include "common.hpp" +#include "vk_capture.h" +namespace vk_capture +{ + +inline void* copyNextPtr(const void* pNext); + +// do nothing by default +template +inline void copyIndirectData(const T&) {} + +inline void copyIndirectData(const char*& value) +{ + const std::size_t len = std::strlen(value) + 1; + char* copy = allocType(len); + std::memcpy(copy, value, len); + value = copy; +} + +template +inline void copyIndirectData(const TStruct*& value) +{ + TStruct* copy = allocType(); + std::memcpy(copy, value, sizeof(TStruct)); + copyIndirectData(*copy); + value = copy; +} +inline void copyIndirectData(VkBaseOutStructure& value); +inline void copyIndirectData(VkBaseInStructure& value); +inline void copyIndirectData(VkOffset2D& value); +inline void copyIndirectData(VkOffset3D& value); +inline void copyIndirectData(VkExtent2D& value); +inline void copyIndirectData(VkExtent3D& value); +inline void copyIndirectData(VkViewport& value); +inline void copyIndirectData(VkRect2D& value); +inline void copyIndirectData(VkClearRect& value); +inline void copyIndirectData(VkComponentMapping& value); +inline void copyIndirectData(VkPhysicalDeviceProperties& value); +inline void copyIndirectData(VkExtensionProperties& value); +inline void copyIndirectData(VkLayerProperties& value); +inline void copyIndirectData(VkApplicationInfo& value); +inline void copyIndirectData(VkAllocationCallbacks& value); +inline void copyIndirectData(VkDeviceQueueCreateInfo& value); +inline void copyIndirectData(VkDeviceCreateInfo& value); +inline void copyIndirectData(VkInstanceCreateInfo& value); +inline void copyIndirectData(VkQueueFamilyProperties& value); +inline void copyIndirectData(VkPhysicalDeviceMemoryProperties& value); +inline void copyIndirectData(VkMemoryAllocateInfo& value); +inline void copyIndirectData(VkMemoryRequirements& value); +inline void copyIndirectData(VkSparseImageFormatProperties& value); +inline void copyIndirectData(VkSparseImageMemoryRequirements& value); +inline void copyIndirectData(VkMemoryType& value); +inline void copyIndirectData(VkMemoryHeap& value); +inline void copyIndirectData(VkMappedMemoryRange& value); +inline void copyIndirectData(VkFormatProperties& value); +inline void copyIndirectData(VkImageFormatProperties& value); +inline void copyIndirectData(VkDescriptorBufferInfo& value); +inline void copyIndirectData(VkDescriptorImageInfo& value); +inline void copyIndirectData(VkWriteDescriptorSet& value); +inline void copyIndirectData(VkCopyDescriptorSet& value); +inline void copyIndirectData(VkBufferCreateInfo& value); +inline void copyIndirectData(VkBufferViewCreateInfo& value); +inline void copyIndirectData(VkImageSubresource& value); +inline void copyIndirectData(VkImageSubresourceLayers& value); +inline void copyIndirectData(VkImageSubresourceRange& value); +inline void copyIndirectData(VkMemoryBarrier& value); +inline void copyIndirectData(VkBufferMemoryBarrier& value); +inline void copyIndirectData(VkImageMemoryBarrier& value); +inline void copyIndirectData(VkImageCreateInfo& value); +inline void copyIndirectData(VkSubresourceLayout& value); +inline void copyIndirectData(VkImageViewCreateInfo& value); +inline void copyIndirectData(VkBufferCopy& value); +inline void copyIndirectData(VkSparseMemoryBind& value); +inline void copyIndirectData(VkSparseImageMemoryBind& value); +inline void copyIndirectData(VkSparseBufferMemoryBindInfo& value); +inline void copyIndirectData(VkSparseImageOpaqueMemoryBindInfo& value); +inline void copyIndirectData(VkSparseImageMemoryBindInfo& value); +inline void copyIndirectData(VkBindSparseInfo& value); +inline void copyIndirectData(VkImageCopy& value); +inline void copyIndirectData(VkImageBlit& value); +inline void copyIndirectData(VkBufferImageCopy& value); +inline void copyIndirectData(VkImageResolve& value); +inline void copyIndirectData(VkShaderModuleCreateInfo& value); +inline void copyIndirectData(VkDescriptorSetLayoutBinding& value); +inline void copyIndirectData(VkDescriptorSetLayoutCreateInfo& value); +inline void copyIndirectData(VkDescriptorPoolSize& value); +inline void copyIndirectData(VkDescriptorPoolCreateInfo& value); +inline void copyIndirectData(VkDescriptorSetAllocateInfo& value); +inline void copyIndirectData(VkSpecializationMapEntry& value); +inline void copyIndirectData(VkSpecializationInfo& value); +inline void copyIndirectData(VkPipelineShaderStageCreateInfo& value); +inline void copyIndirectData(VkComputePipelineCreateInfo& value); +inline void copyIndirectData(VkVertexInputBindingDescription& value); +inline void copyIndirectData(VkVertexInputAttributeDescription& value); +inline void copyIndirectData(VkPipelineVertexInputStateCreateInfo& value); +inline void copyIndirectData(VkPipelineInputAssemblyStateCreateInfo& value); +inline void copyIndirectData(VkPipelineTessellationStateCreateInfo& value); +inline void copyIndirectData(VkPipelineViewportStateCreateInfo& value); +inline void copyIndirectData(VkPipelineRasterizationStateCreateInfo& value); +inline void copyIndirectData(VkPipelineMultisampleStateCreateInfo& value); +inline void copyIndirectData(VkPipelineColorBlendAttachmentState& value); +inline void copyIndirectData(VkPipelineColorBlendStateCreateInfo& value); +inline void copyIndirectData(VkPipelineDynamicStateCreateInfo& value); +inline void copyIndirectData(VkStencilOpState& value); +inline void copyIndirectData(VkPipelineDepthStencilStateCreateInfo& value); +inline void copyIndirectData(VkGraphicsPipelineCreateInfo& value); +inline void copyIndirectData(VkPipelineCacheCreateInfo& value); +inline void copyIndirectData(VkPipelineCacheHeaderVersionOne& value); +inline void copyIndirectData(VkPushConstantRange& value); +inline void copyIndirectData(VkPipelineLayoutCreateInfo& value); +inline void copyIndirectData(VkSamplerCreateInfo& value); +inline void copyIndirectData(VkCommandPoolCreateInfo& value); +inline void copyIndirectData(VkCommandBufferAllocateInfo& value); +inline void copyIndirectData(VkCommandBufferInheritanceInfo& value); +inline void copyIndirectData(VkCommandBufferBeginInfo& value); +inline void copyIndirectData(VkRenderPassBeginInfo& value); +inline void copyIndirectData(VkClearDepthStencilValue& value); +inline void copyIndirectData(VkClearAttachment& value); +inline void copyIndirectData(VkAttachmentDescription& value); +inline void copyIndirectData(VkAttachmentReference& value); +inline void copyIndirectData(VkSubpassDescription& value); +inline void copyIndirectData(VkSubpassDependency& value); +inline void copyIndirectData(VkRenderPassCreateInfo& value); +inline void copyIndirectData(VkEventCreateInfo& value); +inline void copyIndirectData(VkFenceCreateInfo& value); +inline void copyIndirectData(VkPhysicalDeviceFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceSparseProperties& value); +inline void copyIndirectData(VkPhysicalDeviceLimits& value); +inline void copyIndirectData(VkSemaphoreCreateInfo& value); +inline void copyIndirectData(VkQueryPoolCreateInfo& value); +inline void copyIndirectData(VkFramebufferCreateInfo& value); +inline void copyIndirectData(VkDrawIndirectCommand& value); +inline void copyIndirectData(VkDrawIndexedIndirectCommand& value); +inline void copyIndirectData(VkDispatchIndirectCommand& value); +inline void copyIndirectData(VkMultiDrawInfoEXT& value); +inline void copyIndirectData(VkMultiDrawIndexedInfoEXT& value); +inline void copyIndirectData(VkSubmitInfo& value); +inline void copyIndirectData(VkDisplayPropertiesKHR& value); +inline void copyIndirectData(VkDisplayPlanePropertiesKHR& value); +inline void copyIndirectData(VkDisplayModeParametersKHR& value); +inline void copyIndirectData(VkDisplayModePropertiesKHR& value); +inline void copyIndirectData(VkDisplayModeCreateInfoKHR& value); +inline void copyIndirectData(VkDisplayPlaneCapabilitiesKHR& value); +inline void copyIndirectData(VkDisplaySurfaceCreateInfoKHR& value); +inline void copyIndirectData(VkDisplayPresentInfoKHR& value); +inline void copyIndirectData(VkSurfaceCapabilitiesKHR& value); +inline void copyIndirectData(VkSurfaceFormatKHR& value); +inline void copyIndirectData(VkSwapchainCreateInfoKHR& value); +inline void copyIndirectData(VkPresentInfoKHR& value); +inline void copyIndirectData(VkDebugReportCallbackCreateInfoEXT& value); +inline void copyIndirectData(VkValidationFlagsEXT& value); +inline void copyIndirectData(VkValidationFeaturesEXT& value); +inline void copyIndirectData(VkPipelineRasterizationStateRasterizationOrderAMD& value); +inline void copyIndirectData(VkDebugMarkerObjectNameInfoEXT& value); +inline void copyIndirectData(VkDebugMarkerObjectTagInfoEXT& value); +inline void copyIndirectData(VkDebugMarkerMarkerInfoEXT& value); +inline void copyIndirectData(VkDedicatedAllocationImageCreateInfoNV& value); +inline void copyIndirectData(VkDedicatedAllocationBufferCreateInfoNV& value); +inline void copyIndirectData(VkDedicatedAllocationMemoryAllocateInfoNV& value); +inline void copyIndirectData(VkExternalImageFormatPropertiesNV& value); +inline void copyIndirectData(VkExternalMemoryImageCreateInfoNV& value); +inline void copyIndirectData(VkExportMemoryAllocateInfoNV& value); +inline void copyIndirectData(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& value); +inline void copyIndirectData(VkDevicePrivateDataCreateInfo& value); +inline void copyIndirectData(VkPrivateDataSlotCreateInfo& value); +inline void copyIndirectData(VkPhysicalDevicePrivateDataFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& value); +inline void copyIndirectData(VkPhysicalDeviceMultiDrawPropertiesEXT& value); +inline void copyIndirectData(VkGraphicsShaderGroupCreateInfoNV& value); +inline void copyIndirectData(VkGraphicsPipelineShaderGroupsCreateInfoNV& value); +inline void copyIndirectData(VkBindShaderGroupIndirectCommandNV& value); +inline void copyIndirectData(VkBindIndexBufferIndirectCommandNV& value); +inline void copyIndirectData(VkBindVertexBufferIndirectCommandNV& value); +inline void copyIndirectData(VkSetStateFlagsIndirectCommandNV& value); +inline void copyIndirectData(VkIndirectCommandsStreamNV& value); +inline void copyIndirectData(VkIndirectCommandsLayoutTokenNV& value); +inline void copyIndirectData(VkIndirectCommandsLayoutCreateInfoNV& value); +inline void copyIndirectData(VkGeneratedCommandsInfoNV& value); +inline void copyIndirectData(VkGeneratedCommandsMemoryRequirementsInfoNV& value); +inline void copyIndirectData(VkPhysicalDeviceFeatures2& value); +inline void copyIndirectData(VkPhysicalDeviceProperties2& value); +inline void copyIndirectData(VkFormatProperties2& value); +inline void copyIndirectData(VkImageFormatProperties2& value); +inline void copyIndirectData(VkPhysicalDeviceImageFormatInfo2& value); +inline void copyIndirectData(VkQueueFamilyProperties2& value); +inline void copyIndirectData(VkPhysicalDeviceMemoryProperties2& value); +inline void copyIndirectData(VkSparseImageFormatProperties2& value); +inline void copyIndirectData(VkPhysicalDeviceSparseImageFormatInfo2& value); +inline void copyIndirectData(VkPhysicalDevicePushDescriptorPropertiesKHR& value); +inline void copyIndirectData(VkConformanceVersion& value); +inline void copyIndirectData(VkPhysicalDeviceDriverProperties& value); +inline void copyIndirectData(VkPresentRegionsKHR& value); +inline void copyIndirectData(VkPresentRegionKHR& value); +inline void copyIndirectData(VkRectLayerKHR& value); +inline void copyIndirectData(VkPhysicalDeviceVariablePointersFeatures& value); +inline void copyIndirectData(VkExternalMemoryProperties& value); +inline void copyIndirectData(VkPhysicalDeviceExternalImageFormatInfo& value); +inline void copyIndirectData(VkExternalImageFormatProperties& value); +inline void copyIndirectData(VkPhysicalDeviceExternalBufferInfo& value); +inline void copyIndirectData(VkExternalBufferProperties& value); +inline void copyIndirectData(VkPhysicalDeviceIDProperties& value); +inline void copyIndirectData(VkExternalMemoryImageCreateInfo& value); +inline void copyIndirectData(VkExternalMemoryBufferCreateInfo& value); +inline void copyIndirectData(VkExportMemoryAllocateInfo& value); +inline void copyIndirectData(VkImportMemoryFdInfoKHR& value); +inline void copyIndirectData(VkMemoryFdPropertiesKHR& value); +inline void copyIndirectData(VkMemoryGetFdInfoKHR& value); +inline void copyIndirectData(VkPhysicalDeviceExternalSemaphoreInfo& value); +inline void copyIndirectData(VkExternalSemaphoreProperties& value); +inline void copyIndirectData(VkExportSemaphoreCreateInfo& value); +inline void copyIndirectData(VkImportSemaphoreFdInfoKHR& value); +inline void copyIndirectData(VkSemaphoreGetFdInfoKHR& value); +inline void copyIndirectData(VkPhysicalDeviceExternalFenceInfo& value); +inline void copyIndirectData(VkExternalFenceProperties& value); +inline void copyIndirectData(VkExportFenceCreateInfo& value); +inline void copyIndirectData(VkImportFenceFdInfoKHR& value); +inline void copyIndirectData(VkFenceGetFdInfoKHR& value); +inline void copyIndirectData(VkPhysicalDeviceMultiviewFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceMultiviewProperties& value); +inline void copyIndirectData(VkRenderPassMultiviewCreateInfo& value); +inline void copyIndirectData(VkSurfaceCapabilities2EXT& value); +inline void copyIndirectData(VkDisplayPowerInfoEXT& value); +inline void copyIndirectData(VkDeviceEventInfoEXT& value); +inline void copyIndirectData(VkDisplayEventInfoEXT& value); +inline void copyIndirectData(VkSwapchainCounterCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceGroupProperties& value); +inline void copyIndirectData(VkMemoryAllocateFlagsInfo& value); +inline void copyIndirectData(VkBindBufferMemoryInfo& value); +inline void copyIndirectData(VkBindBufferMemoryDeviceGroupInfo& value); +inline void copyIndirectData(VkBindImageMemoryInfo& value); +inline void copyIndirectData(VkBindImageMemoryDeviceGroupInfo& value); +inline void copyIndirectData(VkDeviceGroupRenderPassBeginInfo& value); +inline void copyIndirectData(VkDeviceGroupCommandBufferBeginInfo& value); +inline void copyIndirectData(VkDeviceGroupSubmitInfo& value); +inline void copyIndirectData(VkDeviceGroupBindSparseInfo& value); +inline void copyIndirectData(VkDeviceGroupPresentCapabilitiesKHR& value); +inline void copyIndirectData(VkImageSwapchainCreateInfoKHR& value); +inline void copyIndirectData(VkBindImageMemorySwapchainInfoKHR& value); +inline void copyIndirectData(VkAcquireNextImageInfoKHR& value); +inline void copyIndirectData(VkDeviceGroupPresentInfoKHR& value); +inline void copyIndirectData(VkDeviceGroupDeviceCreateInfo& value); +inline void copyIndirectData(VkDeviceGroupSwapchainCreateInfoKHR& value); +inline void copyIndirectData(VkDescriptorUpdateTemplateEntry& value); +inline void copyIndirectData(VkDescriptorUpdateTemplateCreateInfo& value); +inline void copyIndirectData(VkXYColorEXT& value); +inline void copyIndirectData(VkPhysicalDevicePresentIdFeaturesKHR& value); +inline void copyIndirectData(VkPresentIdKHR& value); +inline void copyIndirectData(VkPhysicalDevicePresentWaitFeaturesKHR& value); +inline void copyIndirectData(VkHdrMetadataEXT& value); +inline void copyIndirectData(VkDisplayNativeHdrSurfaceCapabilitiesAMD& value); +inline void copyIndirectData(VkSwapchainDisplayNativeHdrCreateInfoAMD& value); +inline void copyIndirectData(VkRefreshCycleDurationGOOGLE& value); +inline void copyIndirectData(VkPastPresentationTimingGOOGLE& value); +inline void copyIndirectData(VkPresentTimesInfoGOOGLE& value); +inline void copyIndirectData(VkPresentTimeGOOGLE& value); +inline void copyIndirectData(VkViewportWScalingNV& value); +inline void copyIndirectData(VkPipelineViewportWScalingStateCreateInfoNV& value); +inline void copyIndirectData(VkViewportSwizzleNV& value); +inline void copyIndirectData(VkPipelineViewportSwizzleStateCreateInfoNV& value); +inline void copyIndirectData(VkPhysicalDeviceDiscardRectanglePropertiesEXT& value); +inline void copyIndirectData(VkPipelineDiscardRectangleStateCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& value); +inline void copyIndirectData(VkInputAttachmentAspectReference& value); +inline void copyIndirectData(VkRenderPassInputAttachmentAspectCreateInfo& value); +inline void copyIndirectData(VkPhysicalDeviceSurfaceInfo2KHR& value); +inline void copyIndirectData(VkSurfaceCapabilities2KHR& value); +inline void copyIndirectData(VkSurfaceFormat2KHR& value); +inline void copyIndirectData(VkDisplayProperties2KHR& value); +inline void copyIndirectData(VkDisplayPlaneProperties2KHR& value); +inline void copyIndirectData(VkDisplayModeProperties2KHR& value); +inline void copyIndirectData(VkDisplayPlaneInfo2KHR& value); +inline void copyIndirectData(VkDisplayPlaneCapabilities2KHR& value); +inline void copyIndirectData(VkSharedPresentSurfaceCapabilitiesKHR& value); +inline void copyIndirectData(VkPhysicalDevice16BitStorageFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceSubgroupProperties& value); +inline void copyIndirectData(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& value); +inline void copyIndirectData(VkBufferMemoryRequirementsInfo2& value); +inline void copyIndirectData(VkDeviceBufferMemoryRequirements& value); +inline void copyIndirectData(VkImageMemoryRequirementsInfo2& value); +inline void copyIndirectData(VkImageSparseMemoryRequirementsInfo2& value); +inline void copyIndirectData(VkDeviceImageMemoryRequirements& value); +inline void copyIndirectData(VkMemoryRequirements2& value); +inline void copyIndirectData(VkSparseImageMemoryRequirements2& value); +inline void copyIndirectData(VkPhysicalDevicePointClippingProperties& value); +inline void copyIndirectData(VkMemoryDedicatedRequirements& value); +inline void copyIndirectData(VkMemoryDedicatedAllocateInfo& value); +inline void copyIndirectData(VkImageViewUsageCreateInfo& value); +inline void copyIndirectData(VkPipelineTessellationDomainOriginStateCreateInfo& value); +inline void copyIndirectData(VkSamplerYcbcrConversionInfo& value); +inline void copyIndirectData(VkSamplerYcbcrConversionCreateInfo& value); +inline void copyIndirectData(VkBindImagePlaneMemoryInfo& value); +inline void copyIndirectData(VkImagePlaneMemoryRequirementsInfo& value); +inline void copyIndirectData(VkPhysicalDeviceSamplerYcbcrConversionFeatures& value); +inline void copyIndirectData(VkSamplerYcbcrConversionImageFormatProperties& value); +inline void copyIndirectData(VkTextureLODGatherFormatPropertiesAMD& value); +inline void copyIndirectData(VkConditionalRenderingBeginInfoEXT& value); +inline void copyIndirectData(VkProtectedSubmitInfo& value); +inline void copyIndirectData(VkPhysicalDeviceProtectedMemoryFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceProtectedMemoryProperties& value); +inline void copyIndirectData(VkDeviceQueueInfo2& value); +inline void copyIndirectData(VkPipelineCoverageToColorStateCreateInfoNV& value); +inline void copyIndirectData(VkPhysicalDeviceSamplerFilterMinmaxProperties& value); +inline void copyIndirectData(VkSampleLocationEXT& value); +inline void copyIndirectData(VkSampleLocationsInfoEXT& value); +inline void copyIndirectData(VkAttachmentSampleLocationsEXT& value); +inline void copyIndirectData(VkSubpassSampleLocationsEXT& value); +inline void copyIndirectData(VkRenderPassSampleLocationsBeginInfoEXT& value); +inline void copyIndirectData(VkPipelineSampleLocationsStateCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceSampleLocationsPropertiesEXT& value); +inline void copyIndirectData(VkMultisamplePropertiesEXT& value); +inline void copyIndirectData(VkSamplerReductionModeCreateInfo& value); +inline void copyIndirectData(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceMultiDrawFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& value); +inline void copyIndirectData(VkPipelineColorBlendAdvancedStateCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceInlineUniformBlockFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceInlineUniformBlockProperties& value); +inline void copyIndirectData(VkWriteDescriptorSetInlineUniformBlock& value); +inline void copyIndirectData(VkDescriptorPoolInlineUniformBlockCreateInfo& value); +inline void copyIndirectData(VkPipelineCoverageModulationStateCreateInfoNV& value); +inline void copyIndirectData(VkImageFormatListCreateInfo& value); +inline void copyIndirectData(VkValidationCacheCreateInfoEXT& value); +inline void copyIndirectData(VkShaderModuleValidationCacheCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceMaintenance3Properties& value); +inline void copyIndirectData(VkPhysicalDeviceMaintenance4Features& value); +inline void copyIndirectData(VkPhysicalDeviceMaintenance4Properties& value); +inline void copyIndirectData(VkDescriptorSetLayoutSupport& value); +inline void copyIndirectData(VkPhysicalDeviceShaderDrawParametersFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceShaderFloat16Int8Features& value); +inline void copyIndirectData(VkPhysicalDeviceFloatControlsProperties& value); +inline void copyIndirectData(VkPhysicalDeviceHostQueryResetFeatures& value); +inline void copyIndirectData(VkShaderResourceUsageAMD& value); +inline void copyIndirectData(VkShaderStatisticsInfoAMD& value); +inline void copyIndirectData(VkDeviceQueueGlobalPriorityCreateInfoKHR& value); +inline void copyIndirectData(VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& value); +inline void copyIndirectData(VkQueueFamilyGlobalPriorityPropertiesKHR& value); +inline void copyIndirectData(VkDebugUtilsObjectNameInfoEXT& value); +inline void copyIndirectData(VkDebugUtilsObjectTagInfoEXT& value); +inline void copyIndirectData(VkDebugUtilsLabelEXT& value); +inline void copyIndirectData(VkDebugUtilsMessengerCreateInfoEXT& value); +inline void copyIndirectData(VkDebugUtilsMessengerCallbackDataEXT& value); +inline void copyIndirectData(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& value); +inline void copyIndirectData(VkDeviceDeviceMemoryReportCreateInfoEXT& value); +inline void copyIndirectData(VkDeviceMemoryReportCallbackDataEXT& value); +inline void copyIndirectData(VkImportMemoryHostPointerInfoEXT& value); +inline void copyIndirectData(VkMemoryHostPointerPropertiesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceExternalMemoryHostPropertiesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceConservativeRasterizationPropertiesEXT& value); +inline void copyIndirectData(VkCalibratedTimestampInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceShaderCorePropertiesAMD& value); +inline void copyIndirectData(VkPhysicalDeviceShaderCoreProperties2AMD& value); +inline void copyIndirectData(VkPipelineRasterizationConservativeStateCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceDescriptorIndexingFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceDescriptorIndexingProperties& value); +inline void copyIndirectData(VkDescriptorSetLayoutBindingFlagsCreateInfo& value); +inline void copyIndirectData(VkDescriptorSetVariableDescriptorCountAllocateInfo& value); +inline void copyIndirectData(VkDescriptorSetVariableDescriptorCountLayoutSupport& value); +inline void copyIndirectData(VkAttachmentDescription2& value); +inline void copyIndirectData(VkAttachmentReference2& value); +inline void copyIndirectData(VkSubpassDescription2& value); +inline void copyIndirectData(VkSubpassDependency2& value); +inline void copyIndirectData(VkRenderPassCreateInfo2& value); +inline void copyIndirectData(VkSubpassBeginInfo& value); +inline void copyIndirectData(VkSubpassEndInfo& value); +inline void copyIndirectData(VkPhysicalDeviceTimelineSemaphoreFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceTimelineSemaphoreProperties& value); +inline void copyIndirectData(VkSemaphoreTypeCreateInfo& value); +inline void copyIndirectData(VkTimelineSemaphoreSubmitInfo& value); +inline void copyIndirectData(VkSemaphoreWaitInfo& value); +inline void copyIndirectData(VkSemaphoreSignalInfo& value); +inline void copyIndirectData(VkVertexInputBindingDivisorDescriptionEXT& value); +inline void copyIndirectData(VkPipelineVertexInputDivisorStateCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& value); +inline void copyIndirectData(VkPhysicalDevicePCIBusInfoPropertiesEXT& value); +inline void copyIndirectData(VkCommandBufferInheritanceConditionalRenderingInfoEXT& value); +inline void copyIndirectData(VkPhysicalDevice8BitStorageFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceConditionalRenderingFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceVulkanMemoryModelFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceShaderAtomicInt64Features& value); +inline void copyIndirectData(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& value); +inline void copyIndirectData(VkQueueFamilyCheckpointPropertiesNV& value); +inline void copyIndirectData(VkCheckpointDataNV& value); +inline void copyIndirectData(VkPhysicalDeviceDepthStencilResolveProperties& value); +inline void copyIndirectData(VkSubpassDescriptionDepthStencilResolve& value); +inline void copyIndirectData(VkImageViewASTCDecodeModeEXT& value); +inline void copyIndirectData(VkPhysicalDeviceASTCDecodeFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceTransformFeedbackFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceTransformFeedbackPropertiesEXT& value); +inline void copyIndirectData(VkPipelineRasterizationStateStreamCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& value); +inline void copyIndirectData(VkPipelineRepresentativeFragmentTestStateCreateInfoNV& value); +inline void copyIndirectData(VkPhysicalDeviceExclusiveScissorFeaturesNV& value); +inline void copyIndirectData(VkPipelineViewportExclusiveScissorStateCreateInfoNV& value); +inline void copyIndirectData(VkPhysicalDeviceCornerSampledImageFeaturesNV& value); +inline void copyIndirectData(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& value); +inline void copyIndirectData(VkPhysicalDeviceShaderImageFootprintFeaturesNV& value); +inline void copyIndirectData(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& value); +inline void copyIndirectData(VkShadingRatePaletteNV& value); +inline void copyIndirectData(VkPipelineViewportShadingRateImageStateCreateInfoNV& value); +inline void copyIndirectData(VkPhysicalDeviceShadingRateImageFeaturesNV& value); +inline void copyIndirectData(VkPhysicalDeviceShadingRateImagePropertiesNV& value); +inline void copyIndirectData(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& value); +inline void copyIndirectData(VkCoarseSampleLocationNV& value); +inline void copyIndirectData(VkCoarseSampleOrderCustomNV& value); +inline void copyIndirectData(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& value); +inline void copyIndirectData(VkPhysicalDeviceMeshShaderFeaturesNV& value); +inline void copyIndirectData(VkPhysicalDeviceMeshShaderPropertiesNV& value); +inline void copyIndirectData(VkDrawMeshTasksIndirectCommandNV& value); +inline void copyIndirectData(VkRayTracingShaderGroupCreateInfoNV& value); +inline void copyIndirectData(VkRayTracingShaderGroupCreateInfoKHR& value); +inline void copyIndirectData(VkRayTracingPipelineCreateInfoNV& value); +inline void copyIndirectData(VkRayTracingPipelineCreateInfoKHR& value); +inline void copyIndirectData(VkGeometryTrianglesNV& value); +inline void copyIndirectData(VkGeometryAABBNV& value); +inline void copyIndirectData(VkGeometryDataNV& value); +inline void copyIndirectData(VkGeometryNV& value); +inline void copyIndirectData(VkAccelerationStructureInfoNV& value); +inline void copyIndirectData(VkAccelerationStructureCreateInfoNV& value); +inline void copyIndirectData(VkBindAccelerationStructureMemoryInfoNV& value); +inline void copyIndirectData(VkWriteDescriptorSetAccelerationStructureKHR& value); +inline void copyIndirectData(VkWriteDescriptorSetAccelerationStructureNV& value); +inline void copyIndirectData(VkAccelerationStructureMemoryRequirementsInfoNV& value); +inline void copyIndirectData(VkPhysicalDeviceAccelerationStructureFeaturesKHR& value); +inline void copyIndirectData(VkPhysicalDeviceRayTracingPipelineFeaturesKHR& value); +inline void copyIndirectData(VkPhysicalDeviceRayQueryFeaturesKHR& value); +inline void copyIndirectData(VkPhysicalDeviceAccelerationStructurePropertiesKHR& value); +inline void copyIndirectData(VkPhysicalDeviceRayTracingPipelinePropertiesKHR& value); +inline void copyIndirectData(VkPhysicalDeviceRayTracingPropertiesNV& value); +inline void copyIndirectData(VkStridedDeviceAddressRegionKHR& value); +inline void copyIndirectData(VkTraceRaysIndirectCommandKHR& value); +inline void copyIndirectData(VkTraceRaysIndirectCommand2KHR& value); +inline void copyIndirectData(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& value); +inline void copyIndirectData(VkDrmFormatModifierPropertiesListEXT& value); +inline void copyIndirectData(VkDrmFormatModifierPropertiesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceImageDrmFormatModifierInfoEXT& value); +inline void copyIndirectData(VkImageDrmFormatModifierListCreateInfoEXT& value); +inline void copyIndirectData(VkImageDrmFormatModifierExplicitCreateInfoEXT& value); +inline void copyIndirectData(VkImageDrmFormatModifierPropertiesEXT& value); +inline void copyIndirectData(VkImageStencilUsageCreateInfo& value); +inline void copyIndirectData(VkDeviceMemoryOverallocationCreateInfoAMD& value); +inline void copyIndirectData(VkPhysicalDeviceFragmentDensityMapFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& value); +inline void copyIndirectData(VkPhysicalDeviceFragmentDensityMapPropertiesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& value); +inline void copyIndirectData(VkRenderPassFragmentDensityMapCreateInfoEXT& value); +inline void copyIndirectData(VkSubpassFragmentDensityMapOffsetEndInfoQCOM& value); +inline void copyIndirectData(VkPhysicalDeviceScalarBlockLayoutFeatures& value); +inline void copyIndirectData(VkSurfaceProtectedCapabilitiesKHR& value); +inline void copyIndirectData(VkPhysicalDeviceUniformBufferStandardLayoutFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceDepthClipEnableFeaturesEXT& value); +inline void copyIndirectData(VkPipelineRasterizationDepthClipStateCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceMemoryBudgetPropertiesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceMemoryPriorityFeaturesEXT& value); +inline void copyIndirectData(VkMemoryPriorityAllocateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceBufferDeviceAddressFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& value); +inline void copyIndirectData(VkBufferDeviceAddressInfo& value); +inline void copyIndirectData(VkBufferOpaqueCaptureAddressCreateInfo& value); +inline void copyIndirectData(VkBufferDeviceAddressCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceImageViewImageFormatInfoEXT& value); +inline void copyIndirectData(VkFilterCubicImageViewImageFormatPropertiesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceImagelessFramebufferFeatures& value); +inline void copyIndirectData(VkFramebufferAttachmentsCreateInfo& value); +inline void copyIndirectData(VkFramebufferAttachmentImageInfo& value); +inline void copyIndirectData(VkRenderPassAttachmentBeginInfo& value); +inline void copyIndirectData(VkPhysicalDeviceTextureCompressionASTCHDRFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceCooperativeMatrixFeaturesNV& value); +inline void copyIndirectData(VkPhysicalDeviceCooperativeMatrixPropertiesNV& value); +inline void copyIndirectData(VkCooperativeMatrixPropertiesNV& value); +inline void copyIndirectData(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& value); +inline void copyIndirectData(VkImageViewHandleInfoNVX& value); +inline void copyIndirectData(VkImageViewAddressPropertiesNVX& value); +inline void copyIndirectData(VkPipelineCreationFeedback& value); +inline void copyIndirectData(VkPipelineCreationFeedbackCreateInfo& value); +inline void copyIndirectData(VkPhysicalDevicePerformanceQueryFeaturesKHR& value); +inline void copyIndirectData(VkPhysicalDevicePerformanceQueryPropertiesKHR& value); +inline void copyIndirectData(VkPerformanceCounterKHR& value); +inline void copyIndirectData(VkPerformanceCounterDescriptionKHR& value); +inline void copyIndirectData(VkQueryPoolPerformanceCreateInfoKHR& value); +inline void copyIndirectData(VkAcquireProfilingLockInfoKHR& value); +inline void copyIndirectData(VkPerformanceQuerySubmitInfoKHR& value); +inline void copyIndirectData(VkHeadlessSurfaceCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceCoverageReductionModeFeaturesNV& value); +inline void copyIndirectData(VkPipelineCoverageReductionStateCreateInfoNV& value); +inline void copyIndirectData(VkFramebufferMixedSamplesCombinationNV& value); +inline void copyIndirectData(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& value); +inline void copyIndirectData(VkPerformanceValueINTEL& value); +inline void copyIndirectData(VkInitializePerformanceApiInfoINTEL& value); +inline void copyIndirectData(VkQueryPoolPerformanceQueryCreateInfoINTEL& value); +inline void copyIndirectData(VkPerformanceMarkerInfoINTEL& value); +inline void copyIndirectData(VkPerformanceStreamMarkerInfoINTEL& value); +inline void copyIndirectData(VkPerformanceOverrideInfoINTEL& value); +inline void copyIndirectData(VkPerformanceConfigurationAcquireInfoINTEL& value); +inline void copyIndirectData(VkPhysicalDeviceShaderClockFeaturesKHR& value); +inline void copyIndirectData(VkPhysicalDeviceIndexTypeUint8FeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& value); +inline void copyIndirectData(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& value); +inline void copyIndirectData(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& value); +inline void copyIndirectData(VkAttachmentReferenceStencilLayout& value); +inline void copyIndirectData(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& value); +inline void copyIndirectData(VkAttachmentDescriptionStencilLayout& value); +inline void copyIndirectData(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& value); +inline void copyIndirectData(VkPipelineInfoKHR& value); +inline void copyIndirectData(VkPipelineExecutablePropertiesKHR& value); +inline void copyIndirectData(VkPipelineExecutableInfoKHR& value); +inline void copyIndirectData(VkPipelineExecutableStatisticKHR& value); +inline void copyIndirectData(VkPipelineExecutableInternalRepresentationKHR& value); +inline void copyIndirectData(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceTexelBufferAlignmentProperties& value); +inline void copyIndirectData(VkPhysicalDeviceSubgroupSizeControlFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceSubgroupSizeControlProperties& value); +inline void copyIndirectData(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& value); +inline void copyIndirectData(VkSubpassShadingPipelineCreateInfoHUAWEI& value); +inline void copyIndirectData(VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& value); +inline void copyIndirectData(VkMemoryOpaqueCaptureAddressAllocateInfo& value); +inline void copyIndirectData(VkDeviceMemoryOpaqueCaptureAddressInfo& value); +inline void copyIndirectData(VkPhysicalDeviceLineRasterizationFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceLineRasterizationPropertiesEXT& value); +inline void copyIndirectData(VkPipelineRasterizationLineStateCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDevicePipelineCreationCacheControlFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceVulkan11Features& value); +inline void copyIndirectData(VkPhysicalDeviceVulkan11Properties& value); +inline void copyIndirectData(VkPhysicalDeviceVulkan12Features& value); +inline void copyIndirectData(VkPhysicalDeviceVulkan12Properties& value); +inline void copyIndirectData(VkPhysicalDeviceVulkan13Features& value); +inline void copyIndirectData(VkPhysicalDeviceVulkan13Properties& value); +inline void copyIndirectData(VkPipelineCompilerControlCreateInfoAMD& value); +inline void copyIndirectData(VkPhysicalDeviceCoherentMemoryFeaturesAMD& value); +inline void copyIndirectData(VkPhysicalDeviceToolProperties& value); +inline void copyIndirectData(VkSamplerCustomBorderColorCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceCustomBorderColorPropertiesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceCustomBorderColorFeaturesEXT& value); +inline void copyIndirectData(VkSamplerBorderColorComponentMappingCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& value); +inline void copyIndirectData(VkAccelerationStructureGeometryTrianglesDataKHR& value); +inline void copyIndirectData(VkAccelerationStructureGeometryAabbsDataKHR& value); +inline void copyIndirectData(VkAccelerationStructureGeometryInstancesDataKHR& value); +inline void copyIndirectData(VkAccelerationStructureGeometryKHR& value); +inline void copyIndirectData(VkAccelerationStructureBuildGeometryInfoKHR& value); +inline void copyIndirectData(VkAccelerationStructureBuildRangeInfoKHR& value); +inline void copyIndirectData(VkAccelerationStructureCreateInfoKHR& value); +inline void copyIndirectData(VkAabbPositionsKHR& value); +inline void copyIndirectData(VkTransformMatrixKHR& value); +inline void copyIndirectData(VkAccelerationStructureInstanceKHR& value); +inline void copyIndirectData(VkAccelerationStructureDeviceAddressInfoKHR& value); +inline void copyIndirectData(VkAccelerationStructureVersionInfoKHR& value); +inline void copyIndirectData(VkCopyAccelerationStructureInfoKHR& value); +inline void copyIndirectData(VkCopyAccelerationStructureToMemoryInfoKHR& value); +inline void copyIndirectData(VkCopyMemoryToAccelerationStructureInfoKHR& value); +inline void copyIndirectData(VkRayTracingPipelineInterfaceCreateInfoKHR& value); +inline void copyIndirectData(VkPipelineLibraryCreateInfoKHR& value); +inline void copyIndirectData(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& value); +inline void copyIndirectData(VkRenderPassTransformBeginInfoQCOM& value); +inline void copyIndirectData(VkCopyCommandTransformInfoQCOM& value); +inline void copyIndirectData(VkCommandBufferInheritanceRenderPassTransformInfoQCOM& value); +inline void copyIndirectData(VkPhysicalDeviceDiagnosticsConfigFeaturesNV& value); +inline void copyIndirectData(VkDeviceDiagnosticsConfigCreateInfoNV& value); +inline void copyIndirectData(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& value); +inline void copyIndirectData(VkPhysicalDeviceRobustness2FeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceRobustness2PropertiesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceImageRobustnessFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& value); +inline void copyIndirectData(VkPhysicalDevice4444FormatsFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& value); +inline void copyIndirectData(VkBufferCopy2& value); +inline void copyIndirectData(VkImageCopy2& value); +inline void copyIndirectData(VkImageBlit2& value); +inline void copyIndirectData(VkBufferImageCopy2& value); +inline void copyIndirectData(VkImageResolve2& value); +inline void copyIndirectData(VkCopyBufferInfo2& value); +inline void copyIndirectData(VkCopyImageInfo2& value); +inline void copyIndirectData(VkBlitImageInfo2& value); +inline void copyIndirectData(VkCopyBufferToImageInfo2& value); +inline void copyIndirectData(VkCopyImageToBufferInfo2& value); +inline void copyIndirectData(VkResolveImageInfo2& value); +inline void copyIndirectData(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& value); +inline void copyIndirectData(VkFragmentShadingRateAttachmentInfoKHR& value); +inline void copyIndirectData(VkPipelineFragmentShadingRateStateCreateInfoKHR& value); +inline void copyIndirectData(VkPhysicalDeviceFragmentShadingRateFeaturesKHR& value); +inline void copyIndirectData(VkPhysicalDeviceFragmentShadingRatePropertiesKHR& value); +inline void copyIndirectData(VkPhysicalDeviceFragmentShadingRateKHR& value); +inline void copyIndirectData(VkPhysicalDeviceShaderTerminateInvocationFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& value); +inline void copyIndirectData(VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& value); +inline void copyIndirectData(VkPipelineFragmentShadingRateEnumStateCreateInfoNV& value); +inline void copyIndirectData(VkAccelerationStructureBuildSizesInfoKHR& value); +inline void copyIndirectData(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE& value); +inline void copyIndirectData(VkMutableDescriptorTypeListVALVE& value); +inline void copyIndirectData(VkMutableDescriptorTypeCreateInfoVALVE& value); +inline void copyIndirectData(VkPhysicalDeviceDepthClipControlFeaturesEXT& value); +inline void copyIndirectData(VkPipelineViewportDepthClipControlCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& value); +inline void copyIndirectData(VkVertexInputBindingDescription2EXT& value); +inline void copyIndirectData(VkVertexInputAttributeDescription2EXT& value); +inline void copyIndirectData(VkPhysicalDeviceColorWriteEnableFeaturesEXT& value); +inline void copyIndirectData(VkPipelineColorWriteCreateInfoEXT& value); +inline void copyIndirectData(VkMemoryBarrier2& value); +inline void copyIndirectData(VkImageMemoryBarrier2& value); +inline void copyIndirectData(VkBufferMemoryBarrier2& value); +inline void copyIndirectData(VkDependencyInfo& value); +inline void copyIndirectData(VkSemaphoreSubmitInfo& value); +inline void copyIndirectData(VkCommandBufferSubmitInfo& value); +inline void copyIndirectData(VkSubmitInfo2& value); +inline void copyIndirectData(VkQueueFamilyCheckpointProperties2NV& value); +inline void copyIndirectData(VkCheckpointData2NV& value); +inline void copyIndirectData(VkPhysicalDeviceSynchronization2Features& value); +inline void copyIndirectData(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& value); +inline void copyIndirectData(VkSubpassResolvePerformanceQueryEXT& value); +inline void copyIndirectData(VkMultisampledRenderToSingleSampledInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceInheritedViewportScissorFeaturesNV& value); +inline void copyIndirectData(VkCommandBufferInheritanceViewportScissorInfoNV& value); +inline void copyIndirectData(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceProvokingVertexFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceProvokingVertexPropertiesEXT& value); +inline void copyIndirectData(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& value); +inline void copyIndirectData(VkCuModuleCreateInfoNVX& value); +inline void copyIndirectData(VkCuFunctionCreateInfoNVX& value); +inline void copyIndirectData(VkCuLaunchInfoNVX& value); +inline void copyIndirectData(VkPhysicalDeviceShaderIntegerDotProductFeatures& value); +inline void copyIndirectData(VkPhysicalDeviceShaderIntegerDotProductProperties& value); +inline void copyIndirectData(VkPhysicalDeviceDrmPropertiesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& value); +inline void copyIndirectData(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& value); +inline void copyIndirectData(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& value); +inline void copyIndirectData(VkAccelerationStructureGeometryMotionTrianglesDataNV& value); +inline void copyIndirectData(VkAccelerationStructureMotionInfoNV& value); +inline void copyIndirectData(VkSRTDataNV& value); +inline void copyIndirectData(VkAccelerationStructureSRTMotionInstanceNV& value); +inline void copyIndirectData(VkAccelerationStructureMatrixMotionInstanceNV& value); +inline void copyIndirectData(VkAccelerationStructureMotionInstanceNV& value); +inline void copyIndirectData(VkMemoryGetRemoteAddressInfoNV& value); +inline void copyIndirectData(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& value); +inline void copyIndirectData(VkFormatProperties3& value); +inline void copyIndirectData(VkDrmFormatModifierPropertiesList2EXT& value); +inline void copyIndirectData(VkDrmFormatModifierProperties2EXT& value); +inline void copyIndirectData(VkPipelineRenderingCreateInfo& value); +inline void copyIndirectData(VkRenderingInfo& value); +inline void copyIndirectData(VkRenderingAttachmentInfo& value); +inline void copyIndirectData(VkRenderingFragmentShadingRateAttachmentInfoKHR& value); +inline void copyIndirectData(VkRenderingFragmentDensityMapAttachmentInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceDynamicRenderingFeatures& value); +inline void copyIndirectData(VkCommandBufferInheritanceRenderingInfo& value); +inline void copyIndirectData(VkAttachmentSampleCountInfoAMD& value); +inline void copyIndirectData(VkMultiviewPerViewAttributesInfoNVX& value); +inline void copyIndirectData(VkPhysicalDeviceImageViewMinLodFeaturesEXT& value); +inline void copyIndirectData(VkImageViewMinLodCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceLinearColorAttachmentFeaturesNV& value); +inline void copyIndirectData(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& value); +inline void copyIndirectData(VkGraphicsPipelineLibraryCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& value); +inline void copyIndirectData(VkDescriptorSetBindingReferenceVALVE& value); +inline void copyIndirectData(VkDescriptorSetLayoutHostMappingInfoVALVE& value); +inline void copyIndirectData(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& value); +inline void copyIndirectData(VkPipelineShaderStageModuleIdentifierCreateInfoEXT& value); +inline void copyIndirectData(VkShaderModuleIdentifierEXT& value); +inline void copyIndirectData(VkImageCompressionControlEXT& value); +inline void copyIndirectData(VkPhysicalDeviceImageCompressionControlFeaturesEXT& value); +inline void copyIndirectData(VkImageCompressionPropertiesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& value); +inline void copyIndirectData(VkImageSubresource2EXT& value); +inline void copyIndirectData(VkSubresourceLayout2EXT& value); +inline void copyIndirectData(VkRenderPassCreationControlEXT& value); +inline void copyIndirectData(VkRenderPassCreationFeedbackInfoEXT& value); +inline void copyIndirectData(VkRenderPassCreationFeedbackCreateInfoEXT& value); +inline void copyIndirectData(VkRenderPassSubpassFeedbackInfoEXT& value); +inline void copyIndirectData(VkRenderPassSubpassFeedbackCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& value); +inline void copyIndirectData(VkPipelinePropertiesIdentifierEXT& value); +inline void copyIndirectData(VkPhysicalDevicePipelinePropertiesFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& value); +inline void copyIndirectData(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& value); +inline void copyIndirectData(VkPhysicalDevicePipelineRobustnessFeaturesEXT& value); +inline void copyIndirectData(VkPipelineRobustnessCreateInfoEXT& value); +inline void copyIndirectData(VkPhysicalDevicePipelineRobustnessPropertiesEXT& value); + +#if defined(VK_USE_PLATFORM_ANDROID_KHR) +inline void copyIndirectData(VkAndroidSurfaceCreateInfoKHR& value); +inline void copyIndirectData(VkNativeBufferUsage2ANDROID& value); +inline void copyIndirectData(VkNativeBufferANDROID& value); +inline void copyIndirectData(VkSwapchainImageCreateInfoANDROID& value); +inline void copyIndirectData(VkPhysicalDevicePresentationPropertiesANDROID& value); +inline void copyIndirectData(VkImportAndroidHardwareBufferInfoANDROID& value); +inline void copyIndirectData(VkAndroidHardwareBufferUsageANDROID& value); +inline void copyIndirectData(VkAndroidHardwareBufferPropertiesANDROID& value); +inline void copyIndirectData(VkMemoryGetAndroidHardwareBufferInfoANDROID& value); +inline void copyIndirectData(VkAndroidHardwareBufferFormatPropertiesANDROID& value); +inline void copyIndirectData(VkExternalFormatANDROID& value); + +#endif // defined(VK_USE_PLATFORM_ANDROID_KHR) + +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) +inline void copyIndirectData(VkDirectFBSurfaceCreateInfoEXT& value); + +#endif // defined(VK_USE_PLATFORM_DIRECTFB_EXT) + +#if defined(VK_USE_PLATFORM_FUCHSIA) +inline void copyIndirectData(VkImagePipeSurfaceCreateInfoFUCHSIA& value); +inline void copyIndirectData(VkImportMemoryZirconHandleInfoFUCHSIA& value); +inline void copyIndirectData(VkMemoryZirconHandlePropertiesFUCHSIA& value); +inline void copyIndirectData(VkMemoryGetZirconHandleInfoFUCHSIA& value); +inline void copyIndirectData(VkImportSemaphoreZirconHandleInfoFUCHSIA& value); +inline void copyIndirectData(VkSemaphoreGetZirconHandleInfoFUCHSIA& value); +inline void copyIndirectData(VkImportMemoryBufferCollectionFUCHSIA& value); +inline void copyIndirectData(VkBufferCollectionImageCreateInfoFUCHSIA& value); +inline void copyIndirectData(VkBufferCollectionBufferCreateInfoFUCHSIA& value); +inline void copyIndirectData(VkBufferCollectionCreateInfoFUCHSIA& value); +inline void copyIndirectData(VkBufferCollectionPropertiesFUCHSIA& value); +inline void copyIndirectData(VkBufferConstraintsInfoFUCHSIA& value); +inline void copyIndirectData(VkSysmemColorSpaceFUCHSIA& value); +inline void copyIndirectData(VkImageFormatConstraintsInfoFUCHSIA& value); +inline void copyIndirectData(VkImageConstraintsInfoFUCHSIA& value); +inline void copyIndirectData(VkBufferCollectionConstraintsInfoFUCHSIA& value); + +#endif // defined(VK_USE_PLATFORM_FUCHSIA) + +#if defined(VK_USE_PLATFORM_GGP) +inline void copyIndirectData(VkStreamDescriptorSurfaceCreateInfoGGP& value); +inline void copyIndirectData(VkPresentFrameTokenGGP& value); + +#endif // defined(VK_USE_PLATFORM_GGP) + +#if defined(VK_USE_PLATFORM_IOS_MVK) +inline void copyIndirectData(VkIOSSurfaceCreateInfoMVK& value); + +#endif // defined(VK_USE_PLATFORM_IOS_MVK) + +#if defined(VK_USE_PLATFORM_MACOS_MVK) +inline void copyIndirectData(VkMacOSSurfaceCreateInfoMVK& value); + +#endif // defined(VK_USE_PLATFORM_MACOS_MVK) + +#if defined(VK_USE_PLATFORM_METAL_EXT) +inline void copyIndirectData(VkMetalSurfaceCreateInfoEXT& value); +inline void copyIndirectData(VkExportMetalObjectCreateInfoEXT& value); +inline void copyIndirectData(VkExportMetalObjectsInfoEXT& value); +inline void copyIndirectData(VkExportMetalDeviceInfoEXT& value); +inline void copyIndirectData(VkExportMetalCommandQueueInfoEXT& value); +inline void copyIndirectData(VkExportMetalBufferInfoEXT& value); +inline void copyIndirectData(VkImportMetalBufferInfoEXT& value); +inline void copyIndirectData(VkExportMetalTextureInfoEXT& value); +inline void copyIndirectData(VkImportMetalTextureInfoEXT& value); +inline void copyIndirectData(VkExportMetalIOSurfaceInfoEXT& value); +inline void copyIndirectData(VkImportMetalIOSurfaceInfoEXT& value); +inline void copyIndirectData(VkExportMetalSharedEventInfoEXT& value); +inline void copyIndirectData(VkImportMetalSharedEventInfoEXT& value); + +#endif // defined(VK_USE_PLATFORM_METAL_EXT) + +#if defined(VK_ENABLE_BETA_EXTENSIONS) +inline void copyIndirectData(VkPhysicalDevicePortabilitySubsetFeaturesKHR& value); +inline void copyIndirectData(VkPhysicalDevicePortabilitySubsetPropertiesKHR& value); +inline void copyIndirectData(VkQueueFamilyVideoPropertiesKHR& value); +inline void copyIndirectData(VkQueueFamilyQueryResultStatusPropertiesKHR& value); +inline void copyIndirectData(VkVideoProfileListInfoKHR& value); +inline void copyIndirectData(VkPhysicalDeviceVideoFormatInfoKHR& value); +inline void copyIndirectData(VkVideoFormatPropertiesKHR& value); +inline void copyIndirectData(VkVideoProfileInfoKHR& value); +inline void copyIndirectData(VkVideoCapabilitiesKHR& value); +inline void copyIndirectData(VkVideoSessionMemoryRequirementsKHR& value); +inline void copyIndirectData(VkBindVideoSessionMemoryInfoKHR& value); +inline void copyIndirectData(VkVideoPictureResourceInfoKHR& value); +inline void copyIndirectData(VkVideoReferenceSlotInfoKHR& value); +inline void copyIndirectData(VkVideoDecodeCapabilitiesKHR& value); +inline void copyIndirectData(VkVideoDecodeUsageInfoKHR& value); +inline void copyIndirectData(VkVideoDecodeInfoKHR& value); +inline void copyIndirectData(VkVideoDecodeH264ProfileInfoEXT& value); +inline void copyIndirectData(VkVideoDecodeH264CapabilitiesEXT& value); +inline void copyIndirectData(VkVideoDecodeH264SessionParametersAddInfoEXT& value); +inline void copyIndirectData(VkVideoDecodeH264SessionParametersCreateInfoEXT& value); +inline void copyIndirectData(VkVideoDecodeH264PictureInfoEXT& value); +inline void copyIndirectData(VkVideoDecodeH264DpbSlotInfoEXT& value); +inline void copyIndirectData(VkVideoDecodeH264MvcInfoEXT& value); +inline void copyIndirectData(VkVideoDecodeH265ProfileInfoEXT& value); +inline void copyIndirectData(VkVideoDecodeH265CapabilitiesEXT& value); +inline void copyIndirectData(VkVideoDecodeH265SessionParametersAddInfoEXT& value); +inline void copyIndirectData(VkVideoDecodeH265SessionParametersCreateInfoEXT& value); +inline void copyIndirectData(VkVideoDecodeH265PictureInfoEXT& value); +inline void copyIndirectData(VkVideoDecodeH265DpbSlotInfoEXT& value); +inline void copyIndirectData(VkVideoSessionCreateInfoKHR& value); +inline void copyIndirectData(VkVideoSessionParametersCreateInfoKHR& value); +inline void copyIndirectData(VkVideoSessionParametersUpdateInfoKHR& value); +inline void copyIndirectData(VkVideoBeginCodingInfoKHR& value); +inline void copyIndirectData(VkVideoEndCodingInfoKHR& value); +inline void copyIndirectData(VkVideoCodingControlInfoKHR& value); +inline void copyIndirectData(VkVideoEncodeUsageInfoKHR& value); +inline void copyIndirectData(VkVideoEncodeInfoKHR& value); +inline void copyIndirectData(VkVideoEncodeRateControlInfoKHR& value); +inline void copyIndirectData(VkVideoEncodeRateControlLayerInfoKHR& value); +inline void copyIndirectData(VkVideoEncodeCapabilitiesKHR& value); +inline void copyIndirectData(VkVideoEncodeH264CapabilitiesEXT& value); +inline void copyIndirectData(VkVideoEncodeH264SessionParametersAddInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH264SessionParametersCreateInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH264DpbSlotInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH264VclFrameInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH264ReferenceListsInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH264EmitPictureParametersInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH264ProfileInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH264NaluSliceInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH264RateControlInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH264QpEXT& value); +inline void copyIndirectData(VkVideoEncodeH264FrameSizeEXT& value); +inline void copyIndirectData(VkVideoEncodeH264RateControlLayerInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH265CapabilitiesEXT& value); +inline void copyIndirectData(VkVideoEncodeH265SessionParametersAddInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH265SessionParametersCreateInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH265VclFrameInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH265EmitPictureParametersInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH265NaluSliceSegmentInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH265RateControlInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH265QpEXT& value); +inline void copyIndirectData(VkVideoEncodeH265FrameSizeEXT& value); +inline void copyIndirectData(VkVideoEncodeH265RateControlLayerInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH265ProfileInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH265DpbSlotInfoEXT& value); +inline void copyIndirectData(VkVideoEncodeH265ReferenceListsInfoEXT& value); + +#endif // defined(VK_ENABLE_BETA_EXTENSIONS) + +#if defined(VK_USE_PLATFORM_SCREEN_QNX) +inline void copyIndirectData(VkScreenSurfaceCreateInfoQNX& value); + +#endif // defined(VK_USE_PLATFORM_SCREEN_QNX) + +#if defined(VK_USE_PLATFORM_VI_NN) +inline void copyIndirectData(VkViSurfaceCreateInfoNN& value); + +#endif // defined(VK_USE_PLATFORM_VI_NN) + +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) +inline void copyIndirectData(VkWaylandSurfaceCreateInfoKHR& value); + +#endif // defined(VK_USE_PLATFORM_WAYLAND_KHR) + +#if defined(VK_USE_PLATFORM_WIN32_KHR) +inline void copyIndirectData(VkWin32SurfaceCreateInfoKHR& value); +inline void copyIndirectData(VkImportMemoryWin32HandleInfoNV& value); +inline void copyIndirectData(VkExportMemoryWin32HandleInfoNV& value); +inline void copyIndirectData(VkWin32KeyedMutexAcquireReleaseInfoNV& value); +inline void copyIndirectData(VkImportMemoryWin32HandleInfoKHR& value); +inline void copyIndirectData(VkExportMemoryWin32HandleInfoKHR& value); +inline void copyIndirectData(VkMemoryWin32HandlePropertiesKHR& value); +inline void copyIndirectData(VkMemoryGetWin32HandleInfoKHR& value); +inline void copyIndirectData(VkWin32KeyedMutexAcquireReleaseInfoKHR& value); +inline void copyIndirectData(VkImportSemaphoreWin32HandleInfoKHR& value); +inline void copyIndirectData(VkExportSemaphoreWin32HandleInfoKHR& value); +inline void copyIndirectData(VkD3D12FenceSubmitInfoKHR& value); +inline void copyIndirectData(VkSemaphoreGetWin32HandleInfoKHR& value); +inline void copyIndirectData(VkImportFenceWin32HandleInfoKHR& value); +inline void copyIndirectData(VkExportFenceWin32HandleInfoKHR& value); +inline void copyIndirectData(VkFenceGetWin32HandleInfoKHR& value); +inline void copyIndirectData(VkSurfaceFullScreenExclusiveInfoEXT& value); +inline void copyIndirectData(VkSurfaceCapabilitiesFullScreenExclusiveEXT& value); + +#endif // defined(VK_USE_PLATFORM_WIN32_KHR) + +#if defined(VK_USE_PLATFORM_XCB_KHR) +inline void copyIndirectData(VkXcbSurfaceCreateInfoKHR& value); + +#endif // defined(VK_USE_PLATFORM_XCB_KHR) + +#if defined(VK_USE_PLATFORM_XLIB_KHR) +inline void copyIndirectData(VkXlibSurfaceCreateInfoKHR& value); +#endif // defined(VK_USE_PLATFORM_XLIB_KHR) + +inline void copyIndirectData([[maybe_unused]] VkBaseOutStructure& value) +{ + if (value.pNext != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pNext, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pNext = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkBaseInStructure& value) +{ + if (value.pNext != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pNext, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pNext = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkOffset2D& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkOffset3D& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkExtent2D& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkExtent3D& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkViewport& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkRect2D& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkClearRect& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkComponentMapping& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceProperties& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkExtensionProperties& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkLayerProperties& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkApplicationInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pApplicationName != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = std::strlen(value.pApplicationName) + 1; + auto copy = allocType(numElements); + std::memcpy(copy, value.pApplicationName, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pApplicationName = copy; + } + + if (value.pEngineName != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = std::strlen(value.pEngineName) + 1; + auto copy = allocType(numElements); + std::memcpy(copy, value.pEngineName, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pEngineName = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkAllocationCallbacks& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceQueueCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pQueuePriorities != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.queueCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pQueuePriorities, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pQueuePriorities = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pQueueCreateInfos != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.queueCreateInfoCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pQueueCreateInfos, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pQueueCreateInfos = copy; + } + + if (value.ppEnabledLayerNames != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.enabledLayerCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.ppEnabledLayerNames, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.ppEnabledLayerNames = copy; + } + + if (value.ppEnabledExtensionNames != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.enabledExtensionCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.ppEnabledExtensionNames, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.ppEnabledExtensionNames = copy; + } + + if (value.pEnabledFeatures != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pEnabledFeatures, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pEnabledFeatures = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkInstanceCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pApplicationInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pApplicationInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pApplicationInfo = copy; + } + + if (value.ppEnabledLayerNames != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.enabledLayerCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.ppEnabledLayerNames, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.ppEnabledLayerNames = copy; + } + + if (value.ppEnabledExtensionNames != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.enabledExtensionCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.ppEnabledExtensionNames, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.ppEnabledExtensionNames = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkQueueFamilyProperties& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMemoryProperties& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryAllocateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryRequirements& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkSparseImageFormatProperties& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkSparseImageMemoryRequirements& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryType& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryHeap& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkMappedMemoryRange& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkFormatProperties& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkImageFormatProperties& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkDescriptorBufferInfo& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkDescriptorImageInfo& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkWriteDescriptorSet& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pImageInfo != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.descriptorCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pImageInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pImageInfo = copy; + } + + if (value.pBufferInfo != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.descriptorCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pBufferInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pBufferInfo = copy; + } + + if (value.pTexelBufferView != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.descriptorCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pTexelBufferView, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pTexelBufferView = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkCopyDescriptorSet& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBufferCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pQueueFamilyIndices != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.queueFamilyIndexCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pQueueFamilyIndices, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pQueueFamilyIndices = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkBufferViewCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageSubresource& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkImageSubresourceLayers& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkImageSubresourceRange& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryBarrier& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBufferMemoryBarrier& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageMemoryBarrier& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pQueueFamilyIndices != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.queueFamilyIndexCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pQueueFamilyIndices, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pQueueFamilyIndices = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkSubresourceLayout& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkImageViewCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBufferCopy& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkSparseMemoryBind& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkSparseImageMemoryBind& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkSparseBufferMemoryBindInfo& value) +{ + if (value.pBinds != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.bindCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pBinds, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pBinds = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkSparseImageOpaqueMemoryBindInfo& value) +{ + if (value.pBinds != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.bindCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pBinds, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pBinds = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkSparseImageMemoryBindInfo& value) +{ + if (value.pBinds != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.bindCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pBinds, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pBinds = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkBindSparseInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pWaitSemaphores != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.waitSemaphoreCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pWaitSemaphores, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pWaitSemaphores = copy; + } + + if (value.pBufferBinds != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.bufferBindCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pBufferBinds, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pBufferBinds = copy; + } + + if (value.pImageOpaqueBinds != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.imageOpaqueBindCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pImageOpaqueBinds, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pImageOpaqueBinds = copy; + } + + if (value.pImageBinds != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.imageBindCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pImageBinds, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pImageBinds = copy; + } + + if (value.pSignalSemaphores != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.signalSemaphoreCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSignalSemaphores, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSignalSemaphores = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkImageCopy& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkImageBlit& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkBufferImageCopy& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkImageResolve& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkShaderModuleCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pCode != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.codeSize / 4; + + auto copy = allocType(numElements); + std::memcpy(copy, value.pCode, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pCode = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDescriptorSetLayoutBinding& value) +{ + if (value.pImmutableSamplers != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.descriptorCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pImmutableSamplers, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pImmutableSamplers = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDescriptorSetLayoutCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pBindings != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.bindingCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pBindings, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pBindings = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDescriptorPoolSize& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkDescriptorPoolCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pPoolSizes != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.poolSizeCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pPoolSizes, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pPoolSizes = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDescriptorSetAllocateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pSetLayouts != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.descriptorSetCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSetLayouts, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSetLayouts = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkSpecializationMapEntry& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkSpecializationInfo& value) +{ + if (value.pMapEntries != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.mapEntryCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pMapEntries, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pMapEntries = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineShaderStageCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pName != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = std::strlen(value.pName) + 1; + auto copy = allocType(numElements); + std::memcpy(copy, value.pName, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pName = copy; + } + + if (value.pSpecializationInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pSpecializationInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSpecializationInfo = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkComputePipelineCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVertexInputBindingDescription& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkVertexInputAttributeDescription& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineVertexInputStateCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pVertexBindingDescriptions != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.vertexBindingDescriptionCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pVertexBindingDescriptions, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pVertexBindingDescriptions = copy; + } + + if (value.pVertexAttributeDescriptions != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.vertexAttributeDescriptionCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pVertexAttributeDescriptions, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pVertexAttributeDescriptions = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineInputAssemblyStateCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineTessellationStateCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineViewportStateCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pViewports != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.viewportCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pViewports, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pViewports = copy; + } + + if (value.pScissors != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.scissorCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pScissors, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pScissors = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineRasterizationStateCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineMultisampleStateCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pSampleMask != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = (value.rasterizationSamples + 31) / 32; + + auto copy = allocType(numElements); + std::memcpy(copy, value.pSampleMask, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSampleMask = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineColorBlendAttachmentState& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineColorBlendStateCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pAttachments != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.attachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pAttachments, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAttachments = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineDynamicStateCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pDynamicStates != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.dynamicStateCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDynamicStates, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDynamicStates = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkStencilOpState& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineDepthStencilStateCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkGraphicsPipelineCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pStages != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.stageCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pStages, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pStages = copy; + } + + if (value.pVertexInputState != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pVertexInputState, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pVertexInputState = copy; + } + + if (value.pInputAssemblyState != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pInputAssemblyState, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pInputAssemblyState = copy; + } + + if (value.pTessellationState != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pTessellationState, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pTessellationState = copy; + } + + if (value.pViewportState != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pViewportState, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pViewportState = copy; + } + + if (value.pRasterizationState != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pRasterizationState, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pRasterizationState = copy; + } + + if (value.pMultisampleState != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pMultisampleState, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pMultisampleState = copy; + } + + if (value.pDepthStencilState != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pDepthStencilState, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDepthStencilState = copy; + } + + if (value.pColorBlendState != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pColorBlendState, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pColorBlendState = copy; + } + + if (value.pDynamicState != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pDynamicState, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDynamicState = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineCacheCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineCacheHeaderVersionOne& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPushConstantRange& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineLayoutCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pSetLayouts != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.setLayoutCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSetLayouts, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSetLayouts = copy; + } + + if (value.pPushConstantRanges != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.pushConstantRangeCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pPushConstantRanges, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pPushConstantRanges = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkSamplerCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCommandPoolCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCommandBufferAllocateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCommandBufferInheritanceInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCommandBufferBeginInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pInheritanceInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pInheritanceInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pInheritanceInfo = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkRenderPassBeginInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pClearValues != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.clearValueCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pClearValues, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pClearValues = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkClearDepthStencilValue& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkClearAttachment& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkAttachmentDescription& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkAttachmentReference& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkSubpassDescription& value) +{ + if (value.pInputAttachments != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.inputAttachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pInputAttachments, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pInputAttachments = copy; + } + + if (value.pColorAttachments != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.colorAttachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pColorAttachments, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pColorAttachments = copy; + } + + if (value.pResolveAttachments != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.colorAttachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pResolveAttachments, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pResolveAttachments = copy; + } + + if (value.pDepthStencilAttachment != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pDepthStencilAttachment, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDepthStencilAttachment = copy; + } + + if (value.pPreserveAttachments != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.preserveAttachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pPreserveAttachments, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pPreserveAttachments = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkSubpassDependency& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkRenderPassCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pAttachments != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.attachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pAttachments, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAttachments = copy; + } + + if (value.pSubpasses != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.subpassCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSubpasses, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSubpasses = copy; + } + + if (value.pDependencies != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.dependencyCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDependencies, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDependencies = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkEventCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkFenceCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFeatures& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSparseProperties& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceLimits& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkSemaphoreCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkQueryPoolCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkFramebufferCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pAttachments != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.attachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pAttachments, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAttachments = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDrawIndirectCommand& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkDrawIndexedIndirectCommand& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkDispatchIndirectCommand& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkMultiDrawInfoEXT& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkMultiDrawIndexedInfoEXT& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkSubmitInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pWaitSemaphores != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.waitSemaphoreCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pWaitSemaphores, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pWaitSemaphores = copy; + } + + if (value.pWaitDstStageMask != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.waitSemaphoreCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pWaitDstStageMask, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pWaitDstStageMask = copy; + } + + if (value.pCommandBuffers != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.commandBufferCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pCommandBuffers, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pCommandBuffers = copy; + } + + if (value.pSignalSemaphores != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.signalSemaphoreCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSignalSemaphores, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSignalSemaphores = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDisplayPropertiesKHR& value) +{ + if (value.displayName != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = std::strlen(value.displayName) + 1; + auto copy = allocType(numElements); + std::memcpy(copy, value.displayName, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.displayName = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDisplayPlanePropertiesKHR& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkDisplayModeParametersKHR& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkDisplayModePropertiesKHR& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkDisplayModeCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDisplayPlaneCapabilitiesKHR& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkDisplaySurfaceCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDisplayPresentInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSurfaceCapabilitiesKHR& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkSurfaceFormatKHR& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkSwapchainCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pQueueFamilyIndices != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.queueFamilyIndexCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pQueueFamilyIndices, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pQueueFamilyIndices = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPresentInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pWaitSemaphores != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.waitSemaphoreCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pWaitSemaphores, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pWaitSemaphores = copy; + } + + if (value.pSwapchains != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.swapchainCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSwapchains, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSwapchains = copy; + } + + if (value.pImageIndices != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.swapchainCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pImageIndices, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pImageIndices = copy; + } + + if (value.pResults != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.swapchainCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pResults, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pResults = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDebugReportCallbackCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkValidationFlagsEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pDisabledValidationChecks != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.disabledValidationCheckCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDisabledValidationChecks, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDisabledValidationChecks = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkValidationFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pEnabledValidationFeatures != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.enabledValidationFeatureCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pEnabledValidationFeatures, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pEnabledValidationFeatures = copy; + } + + if (value.pDisabledValidationFeatures != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.disabledValidationFeatureCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDisabledValidationFeatures, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDisabledValidationFeatures = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineRasterizationStateRasterizationOrderAMD& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDebugMarkerObjectNameInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pObjectName != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = std::strlen(value.pObjectName) + 1; + auto copy = allocType(numElements); + std::memcpy(copy, value.pObjectName, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pObjectName = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDebugMarkerObjectTagInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDebugMarkerMarkerInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pMarkerName != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = std::strlen(value.pMarkerName) + 1; + auto copy = allocType(numElements); + std::memcpy(copy, value.pMarkerName, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pMarkerName = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDedicatedAllocationImageCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDedicatedAllocationBufferCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDedicatedAllocationMemoryAllocateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExternalImageFormatPropertiesNV& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkExternalMemoryImageCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExportMemoryAllocateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDevicePrivateDataCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPrivateDataSlotCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePrivateDataFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMultiDrawPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkGraphicsShaderGroupCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pStages != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.stageCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pStages, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pStages = copy; + } + + if (value.pVertexInputState != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pVertexInputState, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pVertexInputState = copy; + } + + if (value.pTessellationState != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pTessellationState, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pTessellationState = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkGraphicsPipelineShaderGroupsCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pGroups != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.groupCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pGroups, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pGroups = copy; + } + + if (value.pPipelines != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.pipelineCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pPipelines, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pPipelines = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkBindShaderGroupIndirectCommandNV& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkBindIndexBufferIndirectCommandNV& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkBindVertexBufferIndirectCommandNV& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkSetStateFlagsIndirectCommandNV& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkIndirectCommandsStreamNV& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkIndirectCommandsLayoutTokenNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pIndexTypes != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.indexTypeCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pIndexTypes, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pIndexTypes = copy; + } + + if (value.pIndexTypeValues != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.indexTypeCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pIndexTypeValues, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pIndexTypeValues = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkIndirectCommandsLayoutCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pTokens != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.tokenCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pTokens, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pTokens = copy; + } + + if (value.pStreamStrides != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.streamCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pStreamStrides, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pStreamStrides = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkGeneratedCommandsInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pStreams != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.streamCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pStreams, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pStreams = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkGeneratedCommandsMemoryRequirementsInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFeatures2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceProperties2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkFormatProperties2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageFormatProperties2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImageFormatInfo2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkQueueFamilyProperties2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMemoryProperties2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSparseImageFormatProperties2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSparseImageFormatInfo2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePushDescriptorPropertiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkConformanceVersion& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDriverProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPresentRegionsKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pRegions != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.swapchainCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pRegions, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pRegions = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPresentRegionKHR& value) +{ + if (value.pRectangles != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.rectangleCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pRectangles, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pRectangles = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkRectLayerKHR& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVariablePointersFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExternalMemoryProperties& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExternalImageFormatInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExternalImageFormatProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExternalBufferInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExternalBufferProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceIDProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExternalMemoryImageCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExternalMemoryBufferCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExportMemoryAllocateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImportMemoryFdInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryFdPropertiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryGetFdInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExternalSemaphoreInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExternalSemaphoreProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExportSemaphoreCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImportSemaphoreFdInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSemaphoreGetFdInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExternalFenceInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExternalFenceProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExportFenceCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImportFenceFdInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkFenceGetFdInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMultiviewFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMultiviewProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkRenderPassMultiviewCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pViewMasks != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.subpassCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pViewMasks, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pViewMasks = copy; + } + + if (value.pViewOffsets != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.dependencyCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pViewOffsets, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pViewOffsets = copy; + } + + if (value.pCorrelationMasks != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.correlationMaskCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pCorrelationMasks, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pCorrelationMasks = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkSurfaceCapabilities2EXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDisplayPowerInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceEventInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDisplayEventInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSwapchainCounterCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceGroupProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryAllocateFlagsInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBindBufferMemoryInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBindBufferMemoryDeviceGroupInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pDeviceIndices != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.deviceIndexCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDeviceIndices, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDeviceIndices = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkBindImageMemoryInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBindImageMemoryDeviceGroupInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pDeviceIndices != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.deviceIndexCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDeviceIndices, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDeviceIndices = copy; + } + + if (value.pSplitInstanceBindRegions != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.splitInstanceBindRegionCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSplitInstanceBindRegions, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSplitInstanceBindRegions = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceGroupRenderPassBeginInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pDeviceRenderAreas != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.deviceRenderAreaCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDeviceRenderAreas, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDeviceRenderAreas = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceGroupCommandBufferBeginInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceGroupSubmitInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pWaitSemaphoreDeviceIndices != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.waitSemaphoreCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pWaitSemaphoreDeviceIndices, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pWaitSemaphoreDeviceIndices = copy; + } + + if (value.pCommandBufferDeviceMasks != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.commandBufferCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pCommandBufferDeviceMasks, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pCommandBufferDeviceMasks = copy; + } + + if (value.pSignalSemaphoreDeviceIndices != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.signalSemaphoreCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSignalSemaphoreDeviceIndices, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSignalSemaphoreDeviceIndices = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceGroupBindSparseInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceGroupPresentCapabilitiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageSwapchainCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBindImageMemorySwapchainInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAcquireNextImageInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceGroupPresentInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pDeviceMasks != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.swapchainCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDeviceMasks, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDeviceMasks = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceGroupDeviceCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pPhysicalDevices != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.physicalDeviceCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pPhysicalDevices, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pPhysicalDevices = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceGroupSwapchainCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDescriptorUpdateTemplateEntry& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkDescriptorUpdateTemplateCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pDescriptorUpdateEntries != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.descriptorUpdateEntryCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDescriptorUpdateEntries, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDescriptorUpdateEntries = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkXYColorEXT& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePresentIdFeaturesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPresentIdKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pPresentIds != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.swapchainCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pPresentIds, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pPresentIds = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePresentWaitFeaturesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkHdrMetadataEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDisplayNativeHdrSurfaceCapabilitiesAMD& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSwapchainDisplayNativeHdrCreateInfoAMD& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkRefreshCycleDurationGOOGLE& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPastPresentationTimingGOOGLE& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPresentTimesInfoGOOGLE& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pTimes != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.swapchainCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pTimes, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pTimes = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPresentTimeGOOGLE& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkViewportWScalingNV& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineViewportWScalingStateCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pViewportWScalings != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.viewportCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pViewportWScalings, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pViewportWScalings = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkViewportSwizzleNV& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineViewportSwizzleStateCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pViewportSwizzles != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.viewportCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pViewportSwizzles, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pViewportSwizzles = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDiscardRectanglePropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineDiscardRectangleStateCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pDiscardRectangles != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.discardRectangleCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDiscardRectangles, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDiscardRectangles = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkInputAttachmentAspectReference& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkRenderPassInputAttachmentAspectCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pAspectReferences != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.aspectReferenceCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pAspectReferences, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAspectReferences = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSurfaceInfo2KHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSurfaceCapabilities2KHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSurfaceFormat2KHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDisplayProperties2KHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDisplayPlaneProperties2KHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDisplayModeProperties2KHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDisplayPlaneInfo2KHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDisplayPlaneCapabilities2KHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSharedPresentSurfaceCapabilitiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevice16BitStorageFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSubgroupProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBufferMemoryRequirementsInfo2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceBufferMemoryRequirements& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pCreateInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pCreateInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pCreateInfo = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkImageMemoryRequirementsInfo2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageSparseMemoryRequirementsInfo2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceImageMemoryRequirements& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pCreateInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pCreateInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pCreateInfo = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryRequirements2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSparseImageMemoryRequirements2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePointClippingProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryDedicatedRequirements& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryDedicatedAllocateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageViewUsageCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineTessellationDomainOriginStateCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSamplerYcbcrConversionInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSamplerYcbcrConversionCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBindImagePlaneMemoryInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImagePlaneMemoryRequirementsInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSamplerYcbcrConversionFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSamplerYcbcrConversionImageFormatProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkTextureLODGatherFormatPropertiesAMD& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkConditionalRenderingBeginInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkProtectedSubmitInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceProtectedMemoryFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceProtectedMemoryProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceQueueInfo2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineCoverageToColorStateCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSamplerFilterMinmaxProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSampleLocationEXT& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkSampleLocationsInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pSampleLocations != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.sampleLocationsCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSampleLocations, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSampleLocations = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkAttachmentSampleLocationsEXT& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkSubpassSampleLocationsEXT& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkRenderPassSampleLocationsBeginInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pAttachmentInitialSampleLocations != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.attachmentInitialSampleLocationsCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pAttachmentInitialSampleLocations, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAttachmentInitialSampleLocations = copy; + } + + if (value.pPostSubpassSampleLocations != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.postSubpassSampleLocationsCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pPostSubpassSampleLocations, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pPostSubpassSampleLocations = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineSampleLocationsStateCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSampleLocationsPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkMultisamplePropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSamplerReductionModeCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMultiDrawFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineColorBlendAdvancedStateCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceInlineUniformBlockFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceInlineUniformBlockProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkWriteDescriptorSetInlineUniformBlock& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDescriptorPoolInlineUniformBlockCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineCoverageModulationStateCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pCoverageModulationTable != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.coverageModulationTableCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pCoverageModulationTable, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pCoverageModulationTable = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkImageFormatListCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pViewFormats != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.viewFormatCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pViewFormats, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pViewFormats = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkValidationCacheCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkShaderModuleValidationCacheCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMaintenance3Properties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMaintenance4Features& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMaintenance4Properties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDescriptorSetLayoutSupport& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderDrawParametersFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderFloat16Int8Features& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFloatControlsProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceHostQueryResetFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkShaderResourceUsageAMD& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkShaderStatisticsInfoAMD& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceQueueGlobalPriorityCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkQueueFamilyGlobalPriorityPropertiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDebugUtilsObjectNameInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pObjectName != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = std::strlen(value.pObjectName) + 1; + auto copy = allocType(numElements); + std::memcpy(copy, value.pObjectName, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pObjectName = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDebugUtilsObjectTagInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDebugUtilsLabelEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pLabelName != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = std::strlen(value.pLabelName) + 1; + auto copy = allocType(numElements); + std::memcpy(copy, value.pLabelName, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pLabelName = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDebugUtilsMessengerCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDebugUtilsMessengerCallbackDataEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pMessageIdName != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = std::strlen(value.pMessageIdName) + 1; + auto copy = allocType(numElements); + std::memcpy(copy, value.pMessageIdName, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pMessageIdName = copy; + } + + if (value.pMessage != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = std::strlen(value.pMessage) + 1; + auto copy = allocType(numElements); + std::memcpy(copy, value.pMessage, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pMessage = copy; + } + + if (value.pQueueLabels != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.queueLabelCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pQueueLabels, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pQueueLabels = copy; + } + + if (value.pCmdBufLabels != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.cmdBufLabelCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pCmdBufLabels, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pCmdBufLabels = copy; + } + + if (value.pObjects != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.objectCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pObjects, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pObjects = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceDeviceMemoryReportCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceMemoryReportCallbackDataEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImportMemoryHostPointerInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryHostPointerPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExternalMemoryHostPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceConservativeRasterizationPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCalibratedTimestampInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderCorePropertiesAMD& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderCoreProperties2AMD& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineRasterizationConservativeStateCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDescriptorIndexingFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDescriptorIndexingProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDescriptorSetLayoutBindingFlagsCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pBindingFlags != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.bindingCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pBindingFlags, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pBindingFlags = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDescriptorSetVariableDescriptorCountAllocateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pDescriptorCounts != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.descriptorSetCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDescriptorCounts, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDescriptorCounts = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDescriptorSetVariableDescriptorCountLayoutSupport& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAttachmentDescription2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAttachmentReference2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSubpassDescription2& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pInputAttachments != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.inputAttachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pInputAttachments, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pInputAttachments = copy; + } + + if (value.pColorAttachments != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.colorAttachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pColorAttachments, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pColorAttachments = copy; + } + + if (value.pResolveAttachments != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.colorAttachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pResolveAttachments, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pResolveAttachments = copy; + } + + if (value.pDepthStencilAttachment != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pDepthStencilAttachment, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDepthStencilAttachment = copy; + } + + if (value.pPreserveAttachments != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.preserveAttachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pPreserveAttachments, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pPreserveAttachments = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkSubpassDependency2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkRenderPassCreateInfo2& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pAttachments != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.attachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pAttachments, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAttachments = copy; + } + + if (value.pSubpasses != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.subpassCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSubpasses, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSubpasses = copy; + } + + if (value.pDependencies != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.dependencyCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDependencies, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDependencies = copy; + } + + if (value.pCorrelatedViewMasks != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.correlatedViewMaskCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pCorrelatedViewMasks, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pCorrelatedViewMasks = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkSubpassBeginInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSubpassEndInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceTimelineSemaphoreFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceTimelineSemaphoreProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSemaphoreTypeCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkTimelineSemaphoreSubmitInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pWaitSemaphoreValues != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.waitSemaphoreValueCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pWaitSemaphoreValues, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pWaitSemaphoreValues = copy; + } + + if (value.pSignalSemaphoreValues != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.signalSemaphoreValueCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSignalSemaphoreValues, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSignalSemaphoreValues = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkSemaphoreWaitInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pSemaphores != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.semaphoreCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSemaphores, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSemaphores = copy; + } + + if (value.pValues != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.semaphoreCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pValues, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pValues = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkSemaphoreSignalInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVertexInputBindingDivisorDescriptionEXT& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineVertexInputDivisorStateCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pVertexBindingDivisors != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.vertexBindingDivisorCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pVertexBindingDivisors, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pVertexBindingDivisors = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePCIBusInfoPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCommandBufferInheritanceConditionalRenderingInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevice8BitStorageFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceConditionalRenderingFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVulkanMemoryModelFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderAtomicInt64Features& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkQueueFamilyCheckpointPropertiesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCheckpointDataNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDepthStencilResolveProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSubpassDescriptionDepthStencilResolve& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pDepthStencilResolveAttachment != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pDepthStencilResolveAttachment, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDepthStencilResolveAttachment = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkImageViewASTCDecodeModeEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceASTCDecodeFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceTransformFeedbackFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceTransformFeedbackPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineRasterizationStateStreamCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineRepresentativeFragmentTestStateCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExclusiveScissorFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineViewportExclusiveScissorStateCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pExclusiveScissors != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.exclusiveScissorCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pExclusiveScissors, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pExclusiveScissors = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceCornerSampledImageFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderImageFootprintFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkShadingRatePaletteNV& value) +{ + if (value.pShadingRatePaletteEntries != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.shadingRatePaletteEntryCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pShadingRatePaletteEntries, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pShadingRatePaletteEntries = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineViewportShadingRateImageStateCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pShadingRatePalettes != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.viewportCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pShadingRatePalettes, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pShadingRatePalettes = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShadingRateImageFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShadingRateImagePropertiesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCoarseSampleLocationNV& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkCoarseSampleOrderCustomNV& value) +{ + if (value.pSampleLocations != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.sampleLocationCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSampleLocations, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSampleLocations = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pCustomSampleOrders != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.customSampleOrderCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pCustomSampleOrders, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pCustomSampleOrders = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMeshShaderFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMeshShaderPropertiesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDrawMeshTasksIndirectCommandNV& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkRayTracingShaderGroupCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkRayTracingShaderGroupCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkRayTracingPipelineCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pStages != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.stageCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pStages, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pStages = copy; + } + + if (value.pGroups != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.groupCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pGroups, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pGroups = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkRayTracingPipelineCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pStages != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.stageCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pStages, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pStages = copy; + } + + if (value.pGroups != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.groupCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pGroups, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pGroups = copy; + } + + if (value.pLibraryInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pLibraryInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pLibraryInfo = copy; + } + + if (value.pLibraryInterface != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pLibraryInterface, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pLibraryInterface = copy; + } + + if (value.pDynamicState != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pDynamicState, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDynamicState = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkGeometryTrianglesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkGeometryAABBNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkGeometryDataNV& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkGeometryNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pGeometries != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.geometryCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pGeometries, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pGeometries = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBindAccelerationStructureMemoryInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pDeviceIndices != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.deviceIndexCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDeviceIndices, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDeviceIndices = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkWriteDescriptorSetAccelerationStructureKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pAccelerationStructures != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.accelerationStructureCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pAccelerationStructures, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAccelerationStructures = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkWriteDescriptorSetAccelerationStructureNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pAccelerationStructures != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.accelerationStructureCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pAccelerationStructures, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAccelerationStructures = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureMemoryRequirementsInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceAccelerationStructureFeaturesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRayTracingPipelineFeaturesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRayQueryFeaturesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceAccelerationStructurePropertiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRayTracingPipelinePropertiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRayTracingPropertiesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkStridedDeviceAddressRegionKHR& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkTraceRaysIndirectCommandKHR& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkTraceRaysIndirectCommand2KHR& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDrmFormatModifierPropertiesListEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pDrmFormatModifierProperties != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.drmFormatModifierCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDrmFormatModifierProperties, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDrmFormatModifierProperties = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDrmFormatModifierPropertiesEXT& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImageDrmFormatModifierInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pQueueFamilyIndices != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.queueFamilyIndexCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pQueueFamilyIndices, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pQueueFamilyIndices = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkImageDrmFormatModifierListCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pDrmFormatModifiers != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.drmFormatModifierCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDrmFormatModifiers, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDrmFormatModifiers = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkImageDrmFormatModifierExplicitCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pPlaneLayouts != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.drmFormatModifierPlaneCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pPlaneLayouts, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pPlaneLayouts = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkImageDrmFormatModifierPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageStencilUsageCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceMemoryOverallocationCreateInfoAMD& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentDensityMapFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentDensityMapPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkRenderPassFragmentDensityMapCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSubpassFragmentDensityMapOffsetEndInfoQCOM& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pFragmentDensityOffsets != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.fragmentDensityOffsetCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pFragmentDensityOffsets, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pFragmentDensityOffsets = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceScalarBlockLayoutFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSurfaceProtectedCapabilitiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceUniformBufferStandardLayoutFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDepthClipEnableFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineRasterizationDepthClipStateCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMemoryBudgetPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMemoryPriorityFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryPriorityAllocateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceBufferDeviceAddressFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBufferDeviceAddressInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBufferOpaqueCaptureAddressCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBufferDeviceAddressCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImageViewImageFormatInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkFilterCubicImageViewImageFormatPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImagelessFramebufferFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkFramebufferAttachmentsCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pAttachmentImageInfos != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.attachmentImageInfoCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pAttachmentImageInfos, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAttachmentImageInfos = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkFramebufferAttachmentImageInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pViewFormats != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.viewFormatCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pViewFormats, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pViewFormats = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkRenderPassAttachmentBeginInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pAttachments != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.attachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pAttachments, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAttachments = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceTextureCompressionASTCHDRFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceCooperativeMatrixFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceCooperativeMatrixPropertiesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCooperativeMatrixPropertiesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageViewHandleInfoNVX& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageViewAddressPropertiesNVX& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineCreationFeedback& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineCreationFeedbackCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pPipelineCreationFeedback != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pPipelineCreationFeedback, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pPipelineCreationFeedback = copy; + } + + if (value.pPipelineStageCreationFeedbacks != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.pipelineStageCreationFeedbackCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pPipelineStageCreationFeedbacks, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pPipelineStageCreationFeedbacks = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePerformanceQueryFeaturesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePerformanceQueryPropertiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPerformanceCounterKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPerformanceCounterDescriptionKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkQueryPoolPerformanceCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pCounterIndices != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.counterIndexCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pCounterIndices, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pCounterIndices = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkAcquireProfilingLockInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPerformanceQuerySubmitInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkHeadlessSurfaceCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceCoverageReductionModeFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineCoverageReductionStateCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkFramebufferMixedSamplesCombinationNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPerformanceValueINTEL& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkInitializePerformanceApiInfoINTEL& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkQueryPoolPerformanceQueryCreateInfoINTEL& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPerformanceMarkerInfoINTEL& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPerformanceStreamMarkerInfoINTEL& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPerformanceOverrideInfoINTEL& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPerformanceConfigurationAcquireInfoINTEL& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderClockFeaturesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceIndexTypeUint8FeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAttachmentReferenceStencilLayout& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAttachmentDescriptionStencilLayout& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineExecutablePropertiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineExecutableInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineExecutableStatisticKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineExecutableInternalRepresentationKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceTexelBufferAlignmentProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSubgroupSizeControlFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSubgroupSizeControlProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSubpassShadingPipelineCreateInfoHUAWEI& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryOpaqueCaptureAddressAllocateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceMemoryOpaqueCaptureAddressInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceLineRasterizationFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceLineRasterizationPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineRasterizationLineStateCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePipelineCreationCacheControlFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVulkan11Features& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVulkan11Properties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVulkan12Features& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVulkan12Properties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVulkan13Features& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVulkan13Properties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineCompilerControlCreateInfoAMD& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceCoherentMemoryFeaturesAMD& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceToolProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSamplerCustomBorderColorCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceCustomBorderColorPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceCustomBorderColorFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSamplerBorderColorComponentMappingCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureGeometryTrianglesDataKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureGeometryAabbsDataKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureGeometryInstancesDataKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureGeometryKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureBuildGeometryInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pGeometries != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.geometryCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pGeometries, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pGeometries = copy; + } + + if (value.ppGeometries != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.geometryCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.ppGeometries, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.ppGeometries = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureBuildRangeInfoKHR& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAabbPositionsKHR& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkTransformMatrixKHR& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureInstanceKHR& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureDeviceAddressInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureVersionInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pVersionData != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = 2 * VK_UUID_SIZE; + + auto copy = allocType(numElements); + std::memcpy(copy, value.pVersionData, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pVersionData = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkCopyAccelerationStructureInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCopyAccelerationStructureToMemoryInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCopyMemoryToAccelerationStructureInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkRayTracingPipelineInterfaceCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineLibraryCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pLibraries != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.libraryCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pLibraries, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pLibraries = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkRenderPassTransformBeginInfoQCOM& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCopyCommandTransformInfoQCOM& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCommandBufferInheritanceRenderPassTransformInfoQCOM& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDiagnosticsConfigFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDeviceDiagnosticsConfigCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRobustness2FeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRobustness2PropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImageRobustnessFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevice4444FormatsFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBufferCopy2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageCopy2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageBlit2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBufferImageCopy2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageResolve2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCopyBufferInfo2& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pRegions != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.regionCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pRegions, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pRegions = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkCopyImageInfo2& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pRegions != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.regionCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pRegions, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pRegions = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkBlitImageInfo2& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pRegions != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.regionCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pRegions, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pRegions = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkCopyBufferToImageInfo2& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pRegions != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.regionCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pRegions, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pRegions = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkCopyImageToBufferInfo2& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pRegions != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.regionCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pRegions, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pRegions = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkResolveImageInfo2& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pRegions != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.regionCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pRegions, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pRegions = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkFragmentShadingRateAttachmentInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pFragmentShadingRateAttachment != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pFragmentShadingRateAttachment, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pFragmentShadingRateAttachment = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineFragmentShadingRateStateCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentShadingRateFeaturesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentShadingRatePropertiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentShadingRateKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderTerminateInvocationFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineFragmentShadingRateEnumStateCreateInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureBuildSizesInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkMutableDescriptorTypeListVALVE& value) +{ + if (value.pDescriptorTypes != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.descriptorTypeCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDescriptorTypes, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDescriptorTypes = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkMutableDescriptorTypeCreateInfoVALVE& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pMutableDescriptorTypeLists != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.mutableDescriptorTypeListCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pMutableDescriptorTypeLists, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pMutableDescriptorTypeLists = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDepthClipControlFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineViewportDepthClipControlCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVertexInputBindingDescription2EXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVertexInputAttributeDescription2EXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceColorWriteEnableFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineColorWriteCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pColorWriteEnables != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.attachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pColorWriteEnables, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pColorWriteEnables = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryBarrier2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageMemoryBarrier2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBufferMemoryBarrier2& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDependencyInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pMemoryBarriers != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.memoryBarrierCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pMemoryBarriers, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pMemoryBarriers = copy; + } + + if (value.pBufferMemoryBarriers != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.bufferMemoryBarrierCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pBufferMemoryBarriers, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pBufferMemoryBarriers = copy; + } + + if (value.pImageMemoryBarriers != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.imageMemoryBarrierCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pImageMemoryBarriers, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pImageMemoryBarriers = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkSemaphoreSubmitInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCommandBufferSubmitInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSubmitInfo2& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pWaitSemaphoreInfos != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.waitSemaphoreInfoCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pWaitSemaphoreInfos, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pWaitSemaphoreInfos = copy; + } + + if (value.pCommandBufferInfos != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.commandBufferInfoCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pCommandBufferInfos, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pCommandBufferInfos = copy; + } + + if (value.pSignalSemaphoreInfos != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.signalSemaphoreInfoCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSignalSemaphoreInfos, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSignalSemaphoreInfos = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkQueueFamilyCheckpointProperties2NV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCheckpointData2NV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSynchronization2Features& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSubpassResolvePerformanceQueryEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkMultisampledRenderToSingleSampledInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceInheritedViewportScissorFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCommandBufferInheritanceViewportScissorInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pViewportDepths != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pViewportDepths, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pViewportDepths = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceProvokingVertexFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceProvokingVertexPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCuModuleCreateInfoNVX& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCuFunctionCreateInfoNVX& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pName != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = std::strlen(value.pName) + 1; + auto copy = allocType(numElements); + std::memcpy(copy, value.pName, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pName = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkCuLaunchInfoNVX& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderIntegerDotProductFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderIntegerDotProductProperties& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDrmPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureGeometryMotionTrianglesDataNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureMotionInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSRTDataNV& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureSRTMotionInstanceNV& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureMatrixMotionInstanceNV& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkAccelerationStructureMotionInstanceNV& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryGetRemoteAddressInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkFormatProperties3& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDrmFormatModifierPropertiesList2EXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pDrmFormatModifierProperties != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.drmFormatModifierCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pDrmFormatModifierProperties, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDrmFormatModifierProperties = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkDrmFormatModifierProperties2EXT& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineRenderingCreateInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pColorAttachmentFormats != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.colorAttachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pColorAttachmentFormats, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pColorAttachmentFormats = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkRenderingInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pColorAttachments != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.colorAttachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pColorAttachments, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pColorAttachments = copy; + } + + if (value.pDepthAttachment != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pDepthAttachment, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pDepthAttachment = copy; + } + + if (value.pStencilAttachment != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pStencilAttachment, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pStencilAttachment = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkRenderingAttachmentInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkRenderingFragmentShadingRateAttachmentInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkRenderingFragmentDensityMapAttachmentInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDynamicRenderingFeatures& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkCommandBufferInheritanceRenderingInfo& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pColorAttachmentFormats != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.colorAttachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pColorAttachmentFormats, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pColorAttachmentFormats = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkAttachmentSampleCountInfoAMD& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pColorAttachmentSamples != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.colorAttachmentCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pColorAttachmentSamples, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pColorAttachmentSamples = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkMultiviewPerViewAttributesInfoNVX& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImageViewMinLodFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageViewMinLodCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceLinearColorAttachmentFeaturesNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkGraphicsPipelineLibraryCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDescriptorSetBindingReferenceVALVE& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkDescriptorSetLayoutHostMappingInfoVALVE& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineShaderStageModuleIdentifierCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pIdentifier != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.identifierSize; + auto copy = allocType(numElements); + std::memcpy(copy, value.pIdentifier, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pIdentifier = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkShaderModuleIdentifierEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageCompressionControlEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pFixedRateFlags != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.compressionControlPlaneCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pFixedRateFlags, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pFixedRateFlags = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImageCompressionControlFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageCompressionPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageSubresource2EXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSubresourceLayout2EXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkRenderPassCreationControlEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkRenderPassCreationFeedbackInfoEXT& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkRenderPassCreationFeedbackCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pRenderPassFeedback != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pRenderPassFeedback, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pRenderPassFeedback = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkRenderPassSubpassFeedbackInfoEXT& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkRenderPassSubpassFeedbackCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pSubpassFeedback != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pSubpassFeedback, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSubpassFeedback = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelinePropertiesIdentifierEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePipelinePropertiesFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePipelineRobustnessFeaturesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPipelineRobustnessCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePipelineRobustnessPropertiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + +inline void copyIndirectData([[maybe_unused]] VkAndroidSurfaceCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.window != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.window, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.window = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkNativeBufferUsage2ANDROID& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkNativeBufferANDROID& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSwapchainImageCreateInfoANDROID& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePresentationPropertiesANDROID& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImportAndroidHardwareBufferInfoANDROID& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.buffer != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.buffer, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.buffer = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkAndroidHardwareBufferUsageANDROID& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAndroidHardwareBufferPropertiesANDROID& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryGetAndroidHardwareBufferInfoANDROID& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkAndroidHardwareBufferFormatPropertiesANDROID& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExternalFormatANDROID& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +#endif // defined(VK_USE_PLATFORM_ANDROID_KHR) + +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) + +inline void copyIndirectData([[maybe_unused]] VkDirectFBSurfaceCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.dfb != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.dfb, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.dfb = copy; + } + + if (value.surface != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.surface, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.surface = copy; + } + +} + +#endif // defined(VK_USE_PLATFORM_DIRECTFB_EXT) + +#if defined(VK_USE_PLATFORM_FUCHSIA) + +inline void copyIndirectData([[maybe_unused]] VkImagePipeSurfaceCreateInfoFUCHSIA& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImportMemoryZirconHandleInfoFUCHSIA& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryZirconHandlePropertiesFUCHSIA& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryGetZirconHandleInfoFUCHSIA& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImportSemaphoreZirconHandleInfoFUCHSIA& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSemaphoreGetZirconHandleInfoFUCHSIA& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImportMemoryBufferCollectionFUCHSIA& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBufferCollectionImageCreateInfoFUCHSIA& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBufferCollectionBufferCreateInfoFUCHSIA& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBufferCollectionCreateInfoFUCHSIA& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBufferCollectionPropertiesFUCHSIA& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBufferConstraintsInfoFUCHSIA& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSysmemColorSpaceFUCHSIA& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImageFormatConstraintsInfoFUCHSIA& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pColorSpaces != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.colorSpaceCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pColorSpaces, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pColorSpaces = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkImageConstraintsInfoFUCHSIA& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pFormatConstraints != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.formatConstraintsCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pFormatConstraints, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pFormatConstraints = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkBufferCollectionConstraintsInfoFUCHSIA& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +#endif // defined(VK_USE_PLATFORM_FUCHSIA) + +#if defined(VK_USE_PLATFORM_GGP) + +inline void copyIndirectData([[maybe_unused]] VkStreamDescriptorSurfaceCreateInfoGGP& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPresentFrameTokenGGP& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +#endif // defined(VK_USE_PLATFORM_GGP) + +#if defined(VK_USE_PLATFORM_IOS_MVK) + +inline void copyIndirectData([[maybe_unused]] VkIOSSurfaceCreateInfoMVK& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +#endif // defined(VK_USE_PLATFORM_IOS_MVK) + +#if defined(VK_USE_PLATFORM_MACOS_MVK) + +inline void copyIndirectData([[maybe_unused]] VkMacOSSurfaceCreateInfoMVK& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +#endif // defined(VK_USE_PLATFORM_MACOS_MVK) + +#if defined(VK_USE_PLATFORM_METAL_EXT) + +inline void copyIndirectData([[maybe_unused]] VkMetalSurfaceCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pLayer != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pLayer, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pLayer = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkExportMetalObjectCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExportMetalObjectsInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExportMetalDeviceInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExportMetalCommandQueueInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExportMetalBufferInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImportMetalBufferInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExportMetalTextureInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImportMetalTextureInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExportMetalIOSurfaceInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImportMetalIOSurfaceInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExportMetalSharedEventInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImportMetalSharedEventInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +#endif // defined(VK_USE_PLATFORM_METAL_EXT) + +#if defined(VK_ENABLE_BETA_EXTENSIONS) + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePortabilitySubsetFeaturesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDevicePortabilitySubsetPropertiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkQueueFamilyVideoPropertiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkQueueFamilyQueryResultStatusPropertiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoProfileListInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pProfiles != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.profileCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pProfiles, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pProfiles = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkPhysicalDeviceVideoFormatInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoFormatPropertiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoProfileInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoCapabilitiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoSessionMemoryRequirementsKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkBindVideoSessionMemoryInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoPictureResourceInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoReferenceSlotInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pPictureResource != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pPictureResource, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pPictureResource = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoDecodeCapabilitiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoDecodeUsageInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoDecodeInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pSetupReferenceSlot != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pSetupReferenceSlot, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSetupReferenceSlot = copy; + } + + if (value.pReferenceSlots != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.referenceSlotCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pReferenceSlots, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pReferenceSlots = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH264ProfileInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH264CapabilitiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH264SessionParametersAddInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pSpsStd != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.spsStdCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSpsStd, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSpsStd = copy; + } + + if (value.pPpsStd != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.ppsStdCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pPpsStd, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pPpsStd = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH264SessionParametersCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pParametersAddInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pParametersAddInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pParametersAddInfo = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH264PictureInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pStdPictureInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pStdPictureInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pStdPictureInfo = copy; + } + + if (value.pSlicesDataOffsets != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.slicesCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSlicesDataOffsets, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSlicesDataOffsets = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH264DpbSlotInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pStdReferenceInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pStdReferenceInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pStdReferenceInfo = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH264MvcInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pStdMvc != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pStdMvc, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pStdMvc = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH265ProfileInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH265CapabilitiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH265SessionParametersAddInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pVpsStd != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.vpsStdCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pVpsStd, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pVpsStd = copy; + } + + if (value.pSpsStd != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.spsStdCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSpsStd, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSpsStd = copy; + } + + if (value.pPpsStd != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.ppsStdCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pPpsStd, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pPpsStd = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH265SessionParametersCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pParametersAddInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pParametersAddInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pParametersAddInfo = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH265PictureInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pStdPictureInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pStdPictureInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pStdPictureInfo = copy; + } + + if (value.pSlicesDataOffsets != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.slicesCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSlicesDataOffsets, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSlicesDataOffsets = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoDecodeH265DpbSlotInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pStdReferenceInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pStdReferenceInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pStdReferenceInfo = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoSessionCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pVideoProfile != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pVideoProfile, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pVideoProfile = copy; + } + + if (value.pStdHeaderVersion != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pStdHeaderVersion, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pStdHeaderVersion = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoSessionParametersCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoSessionParametersUpdateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoBeginCodingInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pReferenceSlots != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.referenceSlotCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pReferenceSlots, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pReferenceSlots = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEndCodingInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoCodingControlInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeUsageInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pSetupReferenceSlot != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pSetupReferenceSlot, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSetupReferenceSlot = copy; + } + + if (value.pReferenceSlots != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.referenceSlotCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pReferenceSlots, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pReferenceSlots = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeRateControlInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pLayerConfigs != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.layerCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pLayerConfigs, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pLayerConfigs = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeRateControlLayerInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeCapabilitiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264CapabilitiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264SessionParametersAddInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pSpsStd != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.spsStdCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSpsStd, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSpsStd = copy; + } + + if (value.pPpsStd != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.ppsStdCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pPpsStd, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pPpsStd = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264SessionParametersCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pParametersAddInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pParametersAddInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pParametersAddInfo = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264DpbSlotInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pStdReferenceInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pStdReferenceInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pStdReferenceInfo = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264VclFrameInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pReferenceFinalLists != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pReferenceFinalLists, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pReferenceFinalLists = copy; + } + + if (value.pNaluSliceEntries != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.naluSliceEntryCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pNaluSliceEntries, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pNaluSliceEntries = copy; + } + + if (value.pCurrentPictureInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pCurrentPictureInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pCurrentPictureInfo = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264ReferenceListsInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pReferenceList0Entries != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.referenceList0EntryCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pReferenceList0Entries, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pReferenceList0Entries = copy; + } + + if (value.pReferenceList1Entries != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.referenceList1EntryCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pReferenceList1Entries, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pReferenceList1Entries = copy; + } + + if (value.pMemMgmtCtrlOperations != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pMemMgmtCtrlOperations, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pMemMgmtCtrlOperations = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264EmitPictureParametersInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.ppsIdEntries != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.ppsIdEntryCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.ppsIdEntries, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.ppsIdEntries = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264ProfileInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264NaluSliceInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pReferenceFinalLists != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pReferenceFinalLists, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pReferenceFinalLists = copy; + } + + if (value.pSliceHeaderStd != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pSliceHeaderStd, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSliceHeaderStd = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264RateControlInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264QpEXT& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264FrameSizeEXT& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH264RateControlLayerInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265CapabilitiesEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265SessionParametersAddInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pVpsStd != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.vpsStdCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pVpsStd, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pVpsStd = copy; + } + + if (value.pSpsStd != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.spsStdCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSpsStd, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSpsStd = copy; + } + + if (value.pPpsStd != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.ppsStdCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pPpsStd, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pPpsStd = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265SessionParametersCreateInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pParametersAddInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pParametersAddInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pParametersAddInfo = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265VclFrameInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pReferenceFinalLists != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pReferenceFinalLists, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pReferenceFinalLists = copy; + } + + if (value.pNaluSliceSegmentEntries != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.naluSliceSegmentEntryCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pNaluSliceSegmentEntries, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pNaluSliceSegmentEntries = copy; + } + + if (value.pCurrentPictureInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pCurrentPictureInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pCurrentPictureInfo = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265EmitPictureParametersInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.ppsIdEntries != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.ppsIdEntryCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.ppsIdEntries, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.ppsIdEntries = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265NaluSliceSegmentInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pReferenceFinalLists != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pReferenceFinalLists, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pReferenceFinalLists = copy; + } + + if (value.pSliceSegmentHeaderStd != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pSliceSegmentHeaderStd, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSliceSegmentHeaderStd = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265RateControlInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265QpEXT& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265FrameSizeEXT& value) +{ +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265RateControlLayerInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265ProfileInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265DpbSlotInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pStdReferenceInfo != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pStdReferenceInfo, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pStdReferenceInfo = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkVideoEncodeH265ReferenceListsInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pReferenceList0Entries != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.referenceList0EntryCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pReferenceList0Entries, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pReferenceList0Entries = copy; + } + + if (value.pReferenceList1Entries != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.referenceList1EntryCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pReferenceList1Entries, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pReferenceList1Entries = copy; + } + + if (value.pReferenceModifications != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pReferenceModifications, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pReferenceModifications = copy; + } + +} + +#endif // defined(VK_ENABLE_BETA_EXTENSIONS) + +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + +inline void copyIndirectData([[maybe_unused]] VkScreenSurfaceCreateInfoQNX& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.context != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.context, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.context = copy; + } + + if (value.window != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.window, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.window = copy; + } + +} + +#endif // defined(VK_USE_PLATFORM_SCREEN_QNX) + +#if defined(VK_USE_PLATFORM_VI_NN) + +inline void copyIndirectData([[maybe_unused]] VkViSurfaceCreateInfoNN& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +#endif // defined(VK_USE_PLATFORM_VI_NN) + +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + +inline void copyIndirectData([[maybe_unused]] VkWaylandSurfaceCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.display != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.display, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.display = copy; + } + + if (value.surface != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.surface, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.surface = copy; + } + +} + +#endif // defined(VK_USE_PLATFORM_WAYLAND_KHR) + +#if defined(VK_USE_PLATFORM_WIN32_KHR) + +inline void copyIndirectData([[maybe_unused]] VkWin32SurfaceCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImportMemoryWin32HandleInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExportMemoryWin32HandleInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pAttributes != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pAttributes, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAttributes = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkWin32KeyedMutexAcquireReleaseInfoNV& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pAcquireSyncs != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.acquireCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pAcquireSyncs, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAcquireSyncs = copy; + } + + if (value.pAcquireKeys != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.acquireCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pAcquireKeys, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAcquireKeys = copy; + } + + if (value.pAcquireTimeoutMilliseconds != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.acquireCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pAcquireTimeoutMilliseconds, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAcquireTimeoutMilliseconds = copy; + } + + if (value.pReleaseSyncs != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.releaseCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pReleaseSyncs, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pReleaseSyncs = copy; + } + + if (value.pReleaseKeys != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.releaseCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pReleaseKeys, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pReleaseKeys = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkImportMemoryWin32HandleInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExportMemoryWin32HandleInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pAttributes != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pAttributes, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAttributes = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryWin32HandlePropertiesKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkMemoryGetWin32HandleInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkWin32KeyedMutexAcquireReleaseInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pAcquireSyncs != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.acquireCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pAcquireSyncs, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAcquireSyncs = copy; + } + + if (value.pAcquireKeys != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.acquireCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pAcquireKeys, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAcquireKeys = copy; + } + + if (value.pAcquireTimeouts != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.acquireCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pAcquireTimeouts, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAcquireTimeouts = copy; + } + + if (value.pReleaseSyncs != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.releaseCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pReleaseSyncs, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pReleaseSyncs = copy; + } + + if (value.pReleaseKeys != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.releaseCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pReleaseKeys, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pReleaseKeys = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkImportSemaphoreWin32HandleInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExportSemaphoreWin32HandleInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pAttributes != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pAttributes, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAttributes = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkD3D12FenceSubmitInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pWaitSemaphoreValues != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.waitSemaphoreValuesCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pWaitSemaphoreValues, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pWaitSemaphoreValues = copy; + } + + if (value.pSignalSemaphoreValues != nullptr) + { + using base_type_t = std::decay_t; + const std::size_t numElements = value.signalSemaphoreValuesCount; + auto copy = allocType(numElements); + std::memcpy(copy, value.pSignalSemaphoreValues, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pSignalSemaphoreValues = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkSemaphoreGetWin32HandleInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkImportFenceWin32HandleInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkExportFenceWin32HandleInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.pAttributes != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.pAttributes, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.pAttributes = copy; + } + +} + +inline void copyIndirectData([[maybe_unused]] VkFenceGetWin32HandleInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSurfaceFullScreenExclusiveInfoEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +inline void copyIndirectData([[maybe_unused]] VkSurfaceCapabilitiesFullScreenExclusiveEXT& value) +{ + value.pNext = copyNextPtr(value.pNext); +} + +#endif // defined(VK_USE_PLATFORM_WIN32_KHR) + +#if defined(VK_USE_PLATFORM_XCB_KHR) + +inline void copyIndirectData([[maybe_unused]] VkXcbSurfaceCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.connection != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.connection, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.connection = copy; + } + +} + +#endif // defined(VK_USE_PLATFORM_XCB_KHR) + +#if defined(VK_USE_PLATFORM_XLIB_KHR) + +inline void copyIndirectData([[maybe_unused]] VkXlibSurfaceCreateInfoKHR& value) +{ + value.pNext = copyNextPtr(value.pNext); + if (value.dpy != nullptr) + { + using base_type_t = std::decay_t; + static constexpr std::size_t numElements = 1; // TODO + auto copy = allocType(numElements); + std::memcpy(copy, value.dpy, numElements * sizeof(base_type_t)); + + for (std::size_t ele = 0; ele < numElements; ++ele) { + copyIndirectData(copy[ele]); + } + value.dpy = copy; + } + +} +#endif // defined(VK_USE_PLATFORM_XLIB_KHR) + +inline void variantWrap(VkInstance value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_INSTANCE; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkPhysicalDevice value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_PHYSICAL_DEVICE; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkDevice value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_DEVICE; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkQueue value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_QUEUE; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkCommandBuffer value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_COMMAND_BUFFER; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkDeviceMemory value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_DEVICE_MEMORY; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkCommandPool value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_COMMAND_POOL; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkBuffer value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_BUFFER; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkBufferView value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_BUFFER_VIEW; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkImage value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_IMAGE; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkImageView value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_IMAGE_VIEW; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkShaderModule value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_SHADER_MODULE; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkPipeline value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_PIPELINE; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkPipelineLayout value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_PIPELINE_LAYOUT; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkSampler value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_SAMPLER; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkDescriptorSet value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_DESCRIPTOR_SET; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkDescriptorSetLayout value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_DESCRIPTOR_SET_LAYOUT; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkDescriptorPool value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_DESCRIPTOR_POOL; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkFence value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_FENCE; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkSemaphore value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_SEMAPHORE; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkEvent value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_EVENT; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkQueryPool value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_QUERY_POOL; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkFramebuffer value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_FRAMEBUFFER; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkRenderPass value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_RENDER_PASS; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkPipelineCache value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_PIPELINE_CACHE; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkIndirectCommandsLayoutNV value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_INDIRECT_COMMANDS_LAYOUT_NV; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkDescriptorUpdateTemplate value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_DESCRIPTOR_UPDATE_TEMPLATE; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkSamplerYcbcrConversion value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_SAMPLER_YCBCR_CONVERSION; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkValidationCacheEXT value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_VALIDATION_CACHE_EXT; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkAccelerationStructureKHR value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_KHR; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkAccelerationStructureNV value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_ACCELERATION_STRUCTURE_NV; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkPerformanceConfigurationINTEL value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_PERFORMANCE_CONFIGURATION_INTEL; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkDeferredOperationKHR value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_DEFERRED_OPERATION_KHR; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkPrivateDataSlot value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_PRIVATE_DATA_SLOT; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkCuModuleNVX value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_CU_MODULE_NVX; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkCuFunctionNVX value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_CU_FUNCTION_NVX; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkDisplayKHR value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_DISPLAY_KHR; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkDisplayModeKHR value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_DISPLAY_MODE_KHR; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkSurfaceKHR value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_SURFACE_KHR; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkSwapchainKHR value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_SWAPCHAIN_KHR; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkDebugReportCallbackEXT value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_DEBUG_REPORT_CALLBACK_EXT; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkDebugUtilsMessengerEXT value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_DEBUG_UTILS_MESSENGER_EXT; + outVariant.objectValue.value = value; +} + +inline void variantWrap(const VkBaseOutStructure& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBaseOutStructure)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBaseInStructure& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBaseInStructure)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkApplicationInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkApplicationInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceQueueCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceQueueCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkInstanceCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkInstanceCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryAllocateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryAllocateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMappedMemoryRange& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMappedMemoryRange)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkWriteDescriptorSet& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkWriteDescriptorSet)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCopyDescriptorSet& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCopyDescriptorSet)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBufferCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBufferCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBufferViewCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBufferViewCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryBarrier& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryBarrier)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBufferMemoryBarrier& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBufferMemoryBarrier)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageMemoryBarrier& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageMemoryBarrier)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageViewCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageViewCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBindSparseInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBindSparseInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkShaderModuleCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkShaderModuleCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDescriptorSetLayoutCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDescriptorSetLayoutCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDescriptorPoolCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDescriptorPoolCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDescriptorSetAllocateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDescriptorSetAllocateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineShaderStageCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineShaderStageCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkComputePipelineCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkComputePipelineCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineVertexInputStateCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineVertexInputStateCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineInputAssemblyStateCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineInputAssemblyStateCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineTessellationStateCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineTessellationStateCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineViewportStateCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineViewportStateCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineRasterizationStateCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineRasterizationStateCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineMultisampleStateCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineMultisampleStateCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineColorBlendStateCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineColorBlendStateCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineDynamicStateCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineDynamicStateCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineDepthStencilStateCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineDepthStencilStateCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkGraphicsPipelineCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkGraphicsPipelineCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineCacheCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineCacheCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineLayoutCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineLayoutCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSamplerCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSamplerCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCommandPoolCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCommandPoolCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCommandBufferAllocateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCommandBufferAllocateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCommandBufferInheritanceInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCommandBufferInheritanceInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCommandBufferBeginInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCommandBufferBeginInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRenderPassBeginInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRenderPassBeginInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRenderPassCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRenderPassCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkEventCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkEventCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkFenceCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkFenceCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSemaphoreCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSemaphoreCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkQueryPoolCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkQueryPoolCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkFramebufferCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkFramebufferCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSubmitInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSubmitInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDisplayModeCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDisplayModeCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDisplaySurfaceCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDisplaySurfaceCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDisplayPresentInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDisplayPresentInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSwapchainCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSwapchainCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPresentInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPresentInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDebugReportCallbackCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDebugReportCallbackCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkValidationFlagsEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkValidationFlagsEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkValidationFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkValidationFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineRasterizationStateRasterizationOrderAMD& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineRasterizationStateRasterizationOrderAMD)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDebugMarkerObjectNameInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDebugMarkerObjectNameInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDebugMarkerObjectTagInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDebugMarkerObjectTagInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDebugMarkerMarkerInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDebugMarkerMarkerInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDedicatedAllocationImageCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDedicatedAllocationImageCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDedicatedAllocationBufferCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDedicatedAllocationBufferCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDedicatedAllocationMemoryAllocateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDedicatedAllocationMemoryAllocateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExternalMemoryImageCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExternalMemoryImageCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExportMemoryAllocateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExportMemoryAllocateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDevicePrivateDataCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDevicePrivateDataCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPrivateDataSlotCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPrivateDataSlotCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePrivateDataFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePrivateDataFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceMultiDrawPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMultiDrawPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkGraphicsShaderGroupCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkGraphicsShaderGroupCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkGraphicsPipelineShaderGroupsCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkGraphicsPipelineShaderGroupsCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkIndirectCommandsLayoutTokenNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkIndirectCommandsLayoutTokenNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkIndirectCommandsLayoutCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkIndirectCommandsLayoutCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkGeneratedCommandsInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkGeneratedCommandsInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkGeneratedCommandsMemoryRequirementsInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkGeneratedCommandsMemoryRequirementsInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceFeatures2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFeatures2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceProperties2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceProperties2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkFormatProperties2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkFormatProperties2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageFormatProperties2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageFormatProperties2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceImageFormatInfo2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImageFormatInfo2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkQueueFamilyProperties2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkQueueFamilyProperties2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceMemoryProperties2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMemoryProperties2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSparseImageFormatProperties2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSparseImageFormatProperties2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceSparseImageFormatInfo2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSparseImageFormatInfo2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePushDescriptorPropertiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePushDescriptorPropertiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceDriverProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDriverProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPresentRegionsKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPresentRegionsKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceVariablePointersFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVariablePointersFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceExternalImageFormatInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExternalImageFormatInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExternalImageFormatProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExternalImageFormatProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceExternalBufferInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExternalBufferInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExternalBufferProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExternalBufferProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceIDProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceIDProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExternalMemoryImageCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExternalMemoryImageCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExternalMemoryBufferCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExternalMemoryBufferCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExportMemoryAllocateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExportMemoryAllocateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImportMemoryFdInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImportMemoryFdInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryFdPropertiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryFdPropertiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryGetFdInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryGetFdInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceExternalSemaphoreInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExternalSemaphoreInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExternalSemaphoreProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExternalSemaphoreProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExportSemaphoreCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExportSemaphoreCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImportSemaphoreFdInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImportSemaphoreFdInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSemaphoreGetFdInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSemaphoreGetFdInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceExternalFenceInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExternalFenceInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExternalFenceProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExternalFenceProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExportFenceCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExportFenceCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImportFenceFdInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImportFenceFdInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkFenceGetFdInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkFenceGetFdInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceMultiviewFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMultiviewFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceMultiviewProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMultiviewProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRenderPassMultiviewCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRenderPassMultiviewCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSurfaceCapabilities2EXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSurfaceCapabilities2EXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDisplayPowerInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDisplayPowerInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceEventInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceEventInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDisplayEventInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDisplayEventInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSwapchainCounterCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSwapchainCounterCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceGroupProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceGroupProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryAllocateFlagsInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryAllocateFlagsInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBindBufferMemoryInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBindBufferMemoryInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBindBufferMemoryDeviceGroupInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBindBufferMemoryDeviceGroupInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBindImageMemoryInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBindImageMemoryInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBindImageMemoryDeviceGroupInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBindImageMemoryDeviceGroupInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceGroupRenderPassBeginInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceGroupRenderPassBeginInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceGroupCommandBufferBeginInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceGroupCommandBufferBeginInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceGroupSubmitInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceGroupSubmitInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceGroupBindSparseInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceGroupBindSparseInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceGroupPresentCapabilitiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceGroupPresentCapabilitiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageSwapchainCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageSwapchainCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBindImageMemorySwapchainInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBindImageMemorySwapchainInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAcquireNextImageInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAcquireNextImageInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceGroupPresentInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceGroupPresentInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceGroupDeviceCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceGroupDeviceCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceGroupSwapchainCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceGroupSwapchainCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDescriptorUpdateTemplateCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDescriptorUpdateTemplateCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePresentIdFeaturesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePresentIdFeaturesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPresentIdKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPresentIdKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePresentWaitFeaturesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePresentWaitFeaturesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkHdrMetadataEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkHdrMetadataEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDisplayNativeHdrSurfaceCapabilitiesAMD& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDisplayNativeHdrSurfaceCapabilitiesAMD)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSwapchainDisplayNativeHdrCreateInfoAMD& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSwapchainDisplayNativeHdrCreateInfoAMD)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPresentTimesInfoGOOGLE& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPresentTimesInfoGOOGLE)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineViewportWScalingStateCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineViewportWScalingStateCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineViewportSwizzleStateCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineViewportSwizzleStateCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceDiscardRectanglePropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDiscardRectanglePropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineDiscardRectangleStateCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineDiscardRectangleStateCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRenderPassInputAttachmentAspectCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRenderPassInputAttachmentAspectCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceSurfaceInfo2KHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSurfaceInfo2KHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSurfaceCapabilities2KHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSurfaceCapabilities2KHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSurfaceFormat2KHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSurfaceFormat2KHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDisplayProperties2KHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDisplayProperties2KHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDisplayPlaneProperties2KHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDisplayPlaneProperties2KHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDisplayModeProperties2KHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDisplayModeProperties2KHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDisplayPlaneInfo2KHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDisplayPlaneInfo2KHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDisplayPlaneCapabilities2KHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDisplayPlaneCapabilities2KHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSharedPresentSurfaceCapabilitiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSharedPresentSurfaceCapabilitiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevice16BitStorageFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevice16BitStorageFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceSubgroupProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSubgroupProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBufferMemoryRequirementsInfo2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBufferMemoryRequirementsInfo2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceBufferMemoryRequirements& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceBufferMemoryRequirements)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageMemoryRequirementsInfo2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageMemoryRequirementsInfo2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageSparseMemoryRequirementsInfo2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageSparseMemoryRequirementsInfo2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceImageMemoryRequirements& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceImageMemoryRequirements)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryRequirements2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryRequirements2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSparseImageMemoryRequirements2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSparseImageMemoryRequirements2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePointClippingProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePointClippingProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryDedicatedRequirements& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryDedicatedRequirements)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryDedicatedAllocateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryDedicatedAllocateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageViewUsageCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageViewUsageCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineTessellationDomainOriginStateCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineTessellationDomainOriginStateCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSamplerYcbcrConversionInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSamplerYcbcrConversionInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSamplerYcbcrConversionCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSamplerYcbcrConversionCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBindImagePlaneMemoryInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBindImagePlaneMemoryInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImagePlaneMemoryRequirementsInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImagePlaneMemoryRequirementsInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceSamplerYcbcrConversionFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSamplerYcbcrConversionImageFormatProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSamplerYcbcrConversionImageFormatProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkTextureLODGatherFormatPropertiesAMD& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkTextureLODGatherFormatPropertiesAMD)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkConditionalRenderingBeginInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkConditionalRenderingBeginInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkProtectedSubmitInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkProtectedSubmitInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceProtectedMemoryFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceProtectedMemoryFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceProtectedMemoryProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceProtectedMemoryProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceQueueInfo2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceQueueInfo2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineCoverageToColorStateCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineCoverageToColorStateCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceSamplerFilterMinmaxProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSamplerFilterMinmaxProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSampleLocationsInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSampleLocationsInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRenderPassSampleLocationsBeginInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRenderPassSampleLocationsBeginInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineSampleLocationsStateCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineSampleLocationsStateCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceSampleLocationsPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSampleLocationsPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMultisamplePropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMultisamplePropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSamplerReductionModeCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSamplerReductionModeCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceMultiDrawFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMultiDrawFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineColorBlendAdvancedStateCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineColorBlendAdvancedStateCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceInlineUniformBlockFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceInlineUniformBlockFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceInlineUniformBlockProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceInlineUniformBlockProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkWriteDescriptorSetInlineUniformBlock& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkWriteDescriptorSetInlineUniformBlock)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDescriptorPoolInlineUniformBlockCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDescriptorPoolInlineUniformBlockCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineCoverageModulationStateCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineCoverageModulationStateCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageFormatListCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageFormatListCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkValidationCacheCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkValidationCacheCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkShaderModuleValidationCacheCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkShaderModuleValidationCacheCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceMaintenance3Properties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMaintenance3Properties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceMaintenance4Features& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMaintenance4Features)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceMaintenance4Properties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMaintenance4Properties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDescriptorSetLayoutSupport& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDescriptorSetLayoutSupport)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderDrawParametersFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderDrawParametersFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderFloat16Int8Features& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderFloat16Int8Features)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceFloatControlsProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFloatControlsProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceHostQueryResetFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceHostQueryResetFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceQueueGlobalPriorityCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceQueueGlobalPriorityCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkQueueFamilyGlobalPriorityPropertiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkQueueFamilyGlobalPriorityPropertiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDebugUtilsObjectNameInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDebugUtilsObjectNameInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDebugUtilsObjectTagInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDebugUtilsObjectTagInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDebugUtilsLabelEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDebugUtilsLabelEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDebugUtilsMessengerCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDebugUtilsMessengerCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDebugUtilsMessengerCallbackDataEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDebugUtilsMessengerCallbackDataEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceDeviceMemoryReportFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceDeviceMemoryReportCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceDeviceMemoryReportCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceMemoryReportCallbackDataEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceMemoryReportCallbackDataEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImportMemoryHostPointerInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImportMemoryHostPointerInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryHostPointerPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryHostPointerPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceExternalMemoryHostPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExternalMemoryHostPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceConservativeRasterizationPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceConservativeRasterizationPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCalibratedTimestampInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCalibratedTimestampInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderCorePropertiesAMD& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderCorePropertiesAMD)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderCoreProperties2AMD& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderCoreProperties2AMD)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineRasterizationConservativeStateCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineRasterizationConservativeStateCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceDescriptorIndexingFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDescriptorIndexingFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceDescriptorIndexingProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDescriptorIndexingProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDescriptorSetLayoutBindingFlagsCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDescriptorSetLayoutBindingFlagsCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDescriptorSetVariableDescriptorCountAllocateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDescriptorSetVariableDescriptorCountAllocateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDescriptorSetVariableDescriptorCountLayoutSupport& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDescriptorSetVariableDescriptorCountLayoutSupport)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAttachmentDescription2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAttachmentDescription2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAttachmentReference2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAttachmentReference2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSubpassDescription2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSubpassDescription2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSubpassDependency2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSubpassDependency2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRenderPassCreateInfo2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRenderPassCreateInfo2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSubpassBeginInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSubpassBeginInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSubpassEndInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSubpassEndInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceTimelineSemaphoreFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceTimelineSemaphoreFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceTimelineSemaphoreProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceTimelineSemaphoreProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSemaphoreTypeCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSemaphoreTypeCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkTimelineSemaphoreSubmitInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkTimelineSemaphoreSubmitInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSemaphoreWaitInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSemaphoreWaitInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSemaphoreSignalInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSemaphoreSignalInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineVertexInputDivisorStateCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineVertexInputDivisorStateCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePCIBusInfoPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePCIBusInfoPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCommandBufferInheritanceConditionalRenderingInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCommandBufferInheritanceConditionalRenderingInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevice8BitStorageFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevice8BitStorageFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceConditionalRenderingFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceVulkanMemoryModelFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVulkanMemoryModelFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderAtomicInt64Features& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderAtomicInt64Features)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderAtomicFloatFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkQueueFamilyCheckpointPropertiesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkQueueFamilyCheckpointPropertiesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCheckpointDataNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCheckpointDataNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceDepthStencilResolveProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDepthStencilResolveProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSubpassDescriptionDepthStencilResolve& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSubpassDescriptionDepthStencilResolve)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageViewASTCDecodeModeEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageViewASTCDecodeModeEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceASTCDecodeFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceASTCDecodeFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceTransformFeedbackFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceTransformFeedbackFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceTransformFeedbackPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceTransformFeedbackPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineRasterizationStateStreamCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineRasterizationStateStreamCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineRepresentativeFragmentTestStateCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineRepresentativeFragmentTestStateCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceExclusiveScissorFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExclusiveScissorFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineViewportExclusiveScissorStateCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineViewportExclusiveScissorStateCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceCornerSampledImageFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceCornerSampledImageFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceComputeShaderDerivativesFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderImageFootprintFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderImageFootprintFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineViewportShadingRateImageStateCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineViewportShadingRateImageStateCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShadingRateImageFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShadingRateImageFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShadingRateImagePropertiesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShadingRateImagePropertiesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceInvocationMaskFeaturesHUAWEI& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineViewportCoarseSampleOrderStateCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceMeshShaderFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMeshShaderFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceMeshShaderPropertiesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMeshShaderPropertiesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRayTracingShaderGroupCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRayTracingShaderGroupCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRayTracingShaderGroupCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRayTracingShaderGroupCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRayTracingPipelineCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRayTracingPipelineCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRayTracingPipelineCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRayTracingPipelineCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkGeometryTrianglesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkGeometryTrianglesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkGeometryAABBNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkGeometryAABBNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkGeometryNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkGeometryNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAccelerationStructureInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAccelerationStructureCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBindAccelerationStructureMemoryInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBindAccelerationStructureMemoryInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkWriteDescriptorSetAccelerationStructureKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkWriteDescriptorSetAccelerationStructureKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkWriteDescriptorSetAccelerationStructureNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkWriteDescriptorSetAccelerationStructureNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAccelerationStructureMemoryRequirementsInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureMemoryRequirementsInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceAccelerationStructureFeaturesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceAccelerationStructureFeaturesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceRayTracingPipelineFeaturesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRayTracingPipelineFeaturesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceRayQueryFeaturesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRayQueryFeaturesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceAccelerationStructurePropertiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceAccelerationStructurePropertiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceRayTracingPipelinePropertiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRayTracingPipelinePropertiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceRayTracingPropertiesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRayTracingPropertiesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDrmFormatModifierPropertiesListEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDrmFormatModifierPropertiesListEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceImageDrmFormatModifierInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImageDrmFormatModifierInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageDrmFormatModifierListCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageDrmFormatModifierListCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageDrmFormatModifierExplicitCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageDrmFormatModifierExplicitCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageDrmFormatModifierPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageDrmFormatModifierPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageStencilUsageCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageStencilUsageCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceMemoryOverallocationCreateInfoAMD& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceMemoryOverallocationCreateInfoAMD)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceFragmentDensityMapFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceFragmentDensityMap2FeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceFragmentDensityMapPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceFragmentDensityMap2PropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRenderPassFragmentDensityMapCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSubpassFragmentDensityMapOffsetEndInfoQCOM& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSubpassFragmentDensityMapOffsetEndInfoQCOM)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceScalarBlockLayoutFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceScalarBlockLayoutFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSurfaceProtectedCapabilitiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSurfaceProtectedCapabilitiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceUniformBufferStandardLayoutFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceDepthClipEnableFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineRasterizationDepthClipStateCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceMemoryBudgetPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMemoryBudgetPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceMemoryPriorityFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMemoryPriorityFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryPriorityAllocateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryPriorityAllocateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceBufferDeviceAddressFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceBufferDeviceAddressFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceBufferDeviceAddressFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBufferDeviceAddressInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBufferDeviceAddressInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBufferOpaqueCaptureAddressCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBufferOpaqueCaptureAddressCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBufferDeviceAddressCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBufferDeviceAddressCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceImageViewImageFormatInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImageViewImageFormatInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkFilterCubicImageViewImageFormatPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkFilterCubicImageViewImageFormatPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceImagelessFramebufferFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImagelessFramebufferFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkFramebufferAttachmentsCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkFramebufferAttachmentsCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkFramebufferAttachmentImageInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkFramebufferAttachmentImageInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRenderPassAttachmentBeginInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRenderPassAttachmentBeginInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceTextureCompressionASTCHDRFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceTextureCompressionASTCHDRFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceCooperativeMatrixFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceCooperativeMatrixFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceCooperativeMatrixPropertiesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceCooperativeMatrixPropertiesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCooperativeMatrixPropertiesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCooperativeMatrixPropertiesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceYcbcrImageArraysFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageViewHandleInfoNVX& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageViewHandleInfoNVX)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageViewAddressPropertiesNVX& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageViewAddressPropertiesNVX)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineCreationFeedbackCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineCreationFeedbackCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePerformanceQueryFeaturesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePerformanceQueryFeaturesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePerformanceQueryPropertiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePerformanceQueryPropertiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPerformanceCounterKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPerformanceCounterKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPerformanceCounterDescriptionKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPerformanceCounterDescriptionKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkQueryPoolPerformanceCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkQueryPoolPerformanceCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAcquireProfilingLockInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAcquireProfilingLockInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPerformanceQuerySubmitInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPerformanceQuerySubmitInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkHeadlessSurfaceCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkHeadlessSurfaceCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceCoverageReductionModeFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceCoverageReductionModeFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineCoverageReductionStateCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineCoverageReductionStateCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkFramebufferMixedSamplesCombinationNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkFramebufferMixedSamplesCombinationNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkInitializePerformanceApiInfoINTEL& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkInitializePerformanceApiInfoINTEL)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkQueryPoolPerformanceQueryCreateInfoINTEL& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkQueryPoolPerformanceQueryCreateInfoINTEL)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPerformanceMarkerInfoINTEL& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPerformanceMarkerInfoINTEL)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPerformanceStreamMarkerInfoINTEL& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPerformanceStreamMarkerInfoINTEL)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPerformanceOverrideInfoINTEL& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPerformanceOverrideInfoINTEL)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPerformanceConfigurationAcquireInfoINTEL& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPerformanceConfigurationAcquireInfoINTEL)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderClockFeaturesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderClockFeaturesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceIndexTypeUint8FeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceIndexTypeUint8FeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderSMBuiltinsPropertiesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderSMBuiltinsPropertiesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderSMBuiltinsFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAttachmentReferenceStencilLayout& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAttachmentReferenceStencilLayout)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAttachmentDescriptionStencilLayout& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAttachmentDescriptionStencilLayout)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineExecutablePropertiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineExecutablePropertiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineExecutableInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineExecutableInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineExecutableStatisticKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineExecutableStatisticKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineExecutableInternalRepresentationKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineExecutableInternalRepresentationKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceTexelBufferAlignmentProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceTexelBufferAlignmentProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceSubgroupSizeControlFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSubgroupSizeControlFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceSubgroupSizeControlProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSubgroupSizeControlProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineShaderStageRequiredSubgroupSizeCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSubpassShadingPipelineCreateInfoHUAWEI& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSubpassShadingPipelineCreateInfoHUAWEI)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceSubpassShadingPropertiesHUAWEI& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSubpassShadingPropertiesHUAWEI)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryOpaqueCaptureAddressAllocateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryOpaqueCaptureAddressAllocateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceMemoryOpaqueCaptureAddressInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceMemoryOpaqueCaptureAddressInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceLineRasterizationFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceLineRasterizationFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceLineRasterizationPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceLineRasterizationPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineRasterizationLineStateCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineRasterizationLineStateCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePipelineCreationCacheControlFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePipelineCreationCacheControlFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceVulkan11Features& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVulkan11Features)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceVulkan11Properties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVulkan11Properties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceVulkan12Features& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVulkan12Features)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceVulkan12Properties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVulkan12Properties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceVulkan13Features& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVulkan13Features)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceVulkan13Properties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVulkan13Properties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineCompilerControlCreateInfoAMD& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineCompilerControlCreateInfoAMD)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceCoherentMemoryFeaturesAMD& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceCoherentMemoryFeaturesAMD)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceToolProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceToolProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSamplerCustomBorderColorCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSamplerCustomBorderColorCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceCustomBorderColorPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceCustomBorderColorPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceCustomBorderColorFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceCustomBorderColorFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSamplerBorderColorComponentMappingCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSamplerBorderColorComponentMappingCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceBorderColorSwizzleFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAccelerationStructureGeometryTrianglesDataKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureGeometryTrianglesDataKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAccelerationStructureGeometryAabbsDataKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureGeometryAabbsDataKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAccelerationStructureGeometryInstancesDataKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureGeometryInstancesDataKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAccelerationStructureGeometryKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureGeometryKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAccelerationStructureBuildGeometryInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureBuildGeometryInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAccelerationStructureCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAccelerationStructureDeviceAddressInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureDeviceAddressInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAccelerationStructureVersionInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureVersionInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCopyAccelerationStructureInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCopyAccelerationStructureInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCopyAccelerationStructureToMemoryInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCopyAccelerationStructureToMemoryInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCopyMemoryToAccelerationStructureInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCopyMemoryToAccelerationStructureInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRayTracingPipelineInterfaceCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRayTracingPipelineInterfaceCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineLibraryCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineLibraryCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceExtendedDynamicStateFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceExtendedDynamicState2FeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRenderPassTransformBeginInfoQCOM& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRenderPassTransformBeginInfoQCOM)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCopyCommandTransformInfoQCOM& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCopyCommandTransformInfoQCOM)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCommandBufferInheritanceRenderPassTransformInfoQCOM& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCommandBufferInheritanceRenderPassTransformInfoQCOM)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceDiagnosticsConfigFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDiagnosticsConfigFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDeviceDiagnosticsConfigCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDeviceDiagnosticsConfigCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceRobustness2FeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRobustness2FeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceRobustness2PropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRobustness2PropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceImageRobustnessFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImageRobustnessFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevice4444FormatsFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevice4444FormatsFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceSubpassShadingFeaturesHUAWEI& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBufferCopy2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBufferCopy2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageCopy2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageCopy2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageBlit2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageBlit2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBufferImageCopy2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBufferImageCopy2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageResolve2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageResolve2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCopyBufferInfo2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCopyBufferInfo2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCopyImageInfo2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCopyImageInfo2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBlitImageInfo2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBlitImageInfo2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCopyBufferToImageInfo2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCopyBufferToImageInfo2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCopyImageToBufferInfo2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCopyImageToBufferInfo2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkResolveImageInfo2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkResolveImageInfo2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkFragmentShadingRateAttachmentInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkFragmentShadingRateAttachmentInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineFragmentShadingRateStateCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineFragmentShadingRateStateCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceFragmentShadingRateFeaturesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentShadingRateFeaturesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceFragmentShadingRatePropertiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentShadingRatePropertiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceFragmentShadingRateKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentShadingRateKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderTerminateInvocationFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderTerminateInvocationFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineFragmentShadingRateEnumStateCreateInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineFragmentShadingRateEnumStateCreateInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAccelerationStructureBuildSizesInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureBuildSizesInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceImage2DViewOf3DFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMutableDescriptorTypeCreateInfoVALVE& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMutableDescriptorTypeCreateInfoVALVE)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceDepthClipControlFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDepthClipControlFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineViewportDepthClipControlCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineViewportDepthClipControlCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceExternalMemoryRDMAFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVertexInputBindingDescription2EXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVertexInputBindingDescription2EXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVertexInputAttributeDescription2EXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVertexInputAttributeDescription2EXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceColorWriteEnableFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceColorWriteEnableFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineColorWriteCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineColorWriteCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryBarrier2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryBarrier2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageMemoryBarrier2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageMemoryBarrier2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBufferMemoryBarrier2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBufferMemoryBarrier2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDependencyInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDependencyInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSemaphoreSubmitInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSemaphoreSubmitInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCommandBufferSubmitInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCommandBufferSubmitInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSubmitInfo2& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSubmitInfo2)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkQueueFamilyCheckpointProperties2NV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkQueueFamilyCheckpointProperties2NV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCheckpointData2NV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCheckpointData2NV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceSynchronization2Features& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSynchronization2Features)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSubpassResolvePerformanceQueryEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSubpassResolvePerformanceQueryEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMultisampledRenderToSingleSampledInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMultisampledRenderToSingleSampledInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceInheritedViewportScissorFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceInheritedViewportScissorFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCommandBufferInheritanceViewportScissorInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCommandBufferInheritanceViewportScissorInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceProvokingVertexFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceProvokingVertexFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceProvokingVertexPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceProvokingVertexPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineRasterizationProvokingVertexStateCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCuModuleCreateInfoNVX& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCuModuleCreateInfoNVX)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCuFunctionCreateInfoNVX& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCuFunctionCreateInfoNVX)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCuLaunchInfoNVX& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCuLaunchInfoNVX)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderIntegerDotProductFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderIntegerDotProductFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderIntegerDotProductProperties& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderIntegerDotProductProperties)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceDrmPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDrmPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceRayTracingMotionBlurFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAccelerationStructureGeometryMotionTrianglesDataNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureGeometryMotionTrianglesDataNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAccelerationStructureMotionInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAccelerationStructureMotionInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryGetRemoteAddressInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryGetRemoteAddressInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkFormatProperties3& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkFormatProperties3)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDrmFormatModifierPropertiesList2EXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDrmFormatModifierPropertiesList2EXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineRenderingCreateInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineRenderingCreateInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRenderingInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRenderingInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRenderingAttachmentInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRenderingAttachmentInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRenderingFragmentShadingRateAttachmentInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRenderingFragmentShadingRateAttachmentInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRenderingFragmentDensityMapAttachmentInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRenderingFragmentDensityMapAttachmentInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceDynamicRenderingFeatures& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDynamicRenderingFeatures)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkCommandBufferInheritanceRenderingInfo& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkCommandBufferInheritanceRenderingInfo)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAttachmentSampleCountInfoAMD& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAttachmentSampleCountInfoAMD)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMultiviewPerViewAttributesInfoNVX& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMultiviewPerViewAttributesInfoNVX)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceImageViewMinLodFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImageViewMinLodFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageViewMinLodCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageViewMinLodCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceLinearColorAttachmentFeaturesNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceLinearColorAttachmentFeaturesNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkGraphicsPipelineLibraryCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkGraphicsPipelineLibraryCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDescriptorSetBindingReferenceVALVE& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDescriptorSetBindingReferenceVALVE)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkDescriptorSetLayoutHostMappingInfoVALVE& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDescriptorSetLayoutHostMappingInfoVALVE)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineShaderStageModuleIdentifierCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineShaderStageModuleIdentifierCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkShaderModuleIdentifierEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkShaderModuleIdentifierEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageCompressionControlEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageCompressionControlEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceImageCompressionControlFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImageCompressionControlFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageCompressionPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageCompressionPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageSubresource2EXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageSubresource2EXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSubresourceLayout2EXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSubresourceLayout2EXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRenderPassCreationControlEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRenderPassCreationControlEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRenderPassCreationFeedbackCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRenderPassCreationFeedbackCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkRenderPassSubpassFeedbackCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkRenderPassSubpassFeedbackCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelinePropertiesIdentifierEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelinePropertiesIdentifierEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePipelinePropertiesFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePipelinePropertiesFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePipelineRobustnessFeaturesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePipelineRobustnessFeaturesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPipelineRobustnessCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPipelineRobustnessCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePipelineRobustnessPropertiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePipelineRobustnessPropertiesEXT)); + copyIndirectData(*valueCopy); +} + +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + +inline void variantWrap(const VkAndroidSurfaceCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAndroidSurfaceCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkNativeBufferANDROID& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkNativeBufferANDROID)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSwapchainImageCreateInfoANDROID& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSwapchainImageCreateInfoANDROID)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePresentationPropertiesANDROID& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePresentationPropertiesANDROID)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImportAndroidHardwareBufferInfoANDROID& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImportAndroidHardwareBufferInfoANDROID)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAndroidHardwareBufferUsageANDROID& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAndroidHardwareBufferUsageANDROID)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAndroidHardwareBufferPropertiesANDROID& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAndroidHardwareBufferPropertiesANDROID)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryGetAndroidHardwareBufferInfoANDROID& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryGetAndroidHardwareBufferInfoANDROID)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkAndroidHardwareBufferFormatPropertiesANDROID& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkAndroidHardwareBufferFormatPropertiesANDROID)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExternalFormatANDROID& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExternalFormatANDROID)); + copyIndirectData(*valueCopy); +} + +#endif // defined(VK_USE_PLATFORM_ANDROID_KHR) + +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) + +inline void variantWrap(const VkDirectFBSurfaceCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkDirectFBSurfaceCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +#endif // defined(VK_USE_PLATFORM_DIRECTFB_EXT) + +#if defined(VK_USE_PLATFORM_FUCHSIA) + +inline void variantWrap(VkBufferCollectionFUCHSIA value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_BUFFER_COLLECTION_FUCHSIA; + outVariant.objectValue.value = value; +} + +inline void variantWrap(const VkImagePipeSurfaceCreateInfoFUCHSIA& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImagePipeSurfaceCreateInfoFUCHSIA)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImportMemoryZirconHandleInfoFUCHSIA& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImportMemoryZirconHandleInfoFUCHSIA)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryZirconHandlePropertiesFUCHSIA& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryZirconHandlePropertiesFUCHSIA)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryGetZirconHandleInfoFUCHSIA& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryGetZirconHandleInfoFUCHSIA)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImportSemaphoreZirconHandleInfoFUCHSIA& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImportSemaphoreZirconHandleInfoFUCHSIA)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSemaphoreGetZirconHandleInfoFUCHSIA& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSemaphoreGetZirconHandleInfoFUCHSIA)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImportMemoryBufferCollectionFUCHSIA& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImportMemoryBufferCollectionFUCHSIA)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBufferCollectionImageCreateInfoFUCHSIA& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBufferCollectionImageCreateInfoFUCHSIA)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBufferCollectionBufferCreateInfoFUCHSIA& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBufferCollectionBufferCreateInfoFUCHSIA)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBufferCollectionCreateInfoFUCHSIA& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBufferCollectionCreateInfoFUCHSIA)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBufferCollectionPropertiesFUCHSIA& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBufferCollectionPropertiesFUCHSIA)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBufferConstraintsInfoFUCHSIA& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBufferConstraintsInfoFUCHSIA)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSysmemColorSpaceFUCHSIA& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSysmemColorSpaceFUCHSIA)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageFormatConstraintsInfoFUCHSIA& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageFormatConstraintsInfoFUCHSIA)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImageConstraintsInfoFUCHSIA& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImageConstraintsInfoFUCHSIA)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBufferCollectionConstraintsInfoFUCHSIA& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBufferCollectionConstraintsInfoFUCHSIA)); + copyIndirectData(*valueCopy); +} + +#endif // defined(VK_USE_PLATFORM_FUCHSIA) + +#if defined(VK_USE_PLATFORM_GGP) + +inline void variantWrap(const VkStreamDescriptorSurfaceCreateInfoGGP& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkStreamDescriptorSurfaceCreateInfoGGP)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPresentFrameTokenGGP& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPresentFrameTokenGGP)); + copyIndirectData(*valueCopy); +} + +#endif // defined(VK_USE_PLATFORM_GGP) + +#if defined(VK_USE_PLATFORM_IOS_MVK) + +inline void variantWrap(const VkIOSSurfaceCreateInfoMVK& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkIOSSurfaceCreateInfoMVK)); + copyIndirectData(*valueCopy); +} + +#endif // defined(VK_USE_PLATFORM_IOS_MVK) + +#if defined(VK_USE_PLATFORM_MACOS_MVK) + +inline void variantWrap(const VkMacOSSurfaceCreateInfoMVK& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMacOSSurfaceCreateInfoMVK)); + copyIndirectData(*valueCopy); +} + +#endif // defined(VK_USE_PLATFORM_MACOS_MVK) + +#if defined(VK_USE_PLATFORM_METAL_EXT) + +inline void variantWrap(const VkMetalSurfaceCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMetalSurfaceCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExportMetalObjectCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExportMetalObjectCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExportMetalObjectsInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExportMetalObjectsInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExportMetalDeviceInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExportMetalDeviceInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExportMetalCommandQueueInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExportMetalCommandQueueInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExportMetalBufferInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExportMetalBufferInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImportMetalBufferInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImportMetalBufferInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExportMetalTextureInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExportMetalTextureInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImportMetalTextureInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImportMetalTextureInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExportMetalIOSurfaceInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExportMetalIOSurfaceInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImportMetalIOSurfaceInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImportMetalIOSurfaceInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExportMetalSharedEventInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExportMetalSharedEventInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImportMetalSharedEventInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImportMetalSharedEventInfoEXT)); + copyIndirectData(*valueCopy); +} + +#endif // defined(VK_USE_PLATFORM_METAL_EXT) + +#if defined(VK_ENABLE_BETA_EXTENSIONS) + +inline void variantWrap(VkVideoSessionKHR value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_VIDEO_SESSION_KHR; + outVariant.objectValue.value = value; +} + +inline void variantWrap(VkVideoSessionParametersKHR value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OBJECT_MWN; + outVariant.objectValue.type = VK_OBJECT_TYPE_VIDEO_SESSION_PARAMETERS_KHR; + outVariant.objectValue.value = value; +} + +inline void variantWrap(const VkPhysicalDevicePortabilitySubsetFeaturesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePortabilitySubsetFeaturesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDevicePortabilitySubsetPropertiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDevicePortabilitySubsetPropertiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkQueueFamilyVideoPropertiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkQueueFamilyVideoPropertiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkQueueFamilyQueryResultStatusPropertiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkQueueFamilyQueryResultStatusPropertiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoProfileListInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoProfileListInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkPhysicalDeviceVideoFormatInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkPhysicalDeviceVideoFormatInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoFormatPropertiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoFormatPropertiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoProfileInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoProfileInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoCapabilitiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoCapabilitiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoSessionMemoryRequirementsKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoSessionMemoryRequirementsKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkBindVideoSessionMemoryInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkBindVideoSessionMemoryInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoPictureResourceInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoPictureResourceInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoReferenceSlotInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoReferenceSlotInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoDecodeCapabilitiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeCapabilitiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoDecodeUsageInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeUsageInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoDecodeInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoDecodeH264ProfileInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH264ProfileInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoDecodeH264CapabilitiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH264CapabilitiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoDecodeH264SessionParametersAddInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH264SessionParametersAddInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoDecodeH264SessionParametersCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH264SessionParametersCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoDecodeH264PictureInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH264PictureInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoDecodeH264DpbSlotInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH264DpbSlotInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoDecodeH264MvcInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH264MvcInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoDecodeH265ProfileInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH265ProfileInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoDecodeH265CapabilitiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH265CapabilitiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoDecodeH265SessionParametersAddInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH265SessionParametersAddInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoDecodeH265SessionParametersCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH265SessionParametersCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoDecodeH265PictureInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH265PictureInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoDecodeH265DpbSlotInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoDecodeH265DpbSlotInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoSessionCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoSessionCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoSessionParametersCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoSessionParametersCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoSessionParametersUpdateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoSessionParametersUpdateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoBeginCodingInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoBeginCodingInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEndCodingInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEndCodingInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoCodingControlInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoCodingControlInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeUsageInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeUsageInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeRateControlInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeRateControlInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeRateControlLayerInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeRateControlLayerInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeCapabilitiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeCapabilitiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH264CapabilitiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264CapabilitiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH264SessionParametersAddInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264SessionParametersAddInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH264SessionParametersCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264SessionParametersCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH264DpbSlotInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264DpbSlotInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH264VclFrameInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264VclFrameInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH264ReferenceListsInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264ReferenceListsInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH264EmitPictureParametersInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264EmitPictureParametersInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH264ProfileInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264ProfileInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH264NaluSliceInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264NaluSliceInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH264RateControlInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264RateControlInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH264RateControlLayerInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH264RateControlLayerInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH265CapabilitiesEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265CapabilitiesEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH265SessionParametersAddInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265SessionParametersAddInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH265SessionParametersCreateInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265SessionParametersCreateInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH265VclFrameInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265VclFrameInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH265EmitPictureParametersInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265EmitPictureParametersInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH265NaluSliceSegmentInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265NaluSliceSegmentInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH265RateControlInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265RateControlInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH265RateControlLayerInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265RateControlLayerInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH265ProfileInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265ProfileInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH265DpbSlotInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265DpbSlotInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkVideoEncodeH265ReferenceListsInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkVideoEncodeH265ReferenceListsInfoEXT)); + copyIndirectData(*valueCopy); +} + +#endif // defined(VK_ENABLE_BETA_EXTENSIONS) + +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + +inline void variantWrap(const VkScreenSurfaceCreateInfoQNX& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkScreenSurfaceCreateInfoQNX)); + copyIndirectData(*valueCopy); +} + +#endif // defined(VK_USE_PLATFORM_SCREEN_QNX) + +#if defined(VK_USE_PLATFORM_VI_NN) + +inline void variantWrap(const VkViSurfaceCreateInfoNN& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkViSurfaceCreateInfoNN)); + copyIndirectData(*valueCopy); +} + +#endif // defined(VK_USE_PLATFORM_VI_NN) + +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + +inline void variantWrap(const VkWaylandSurfaceCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkWaylandSurfaceCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +#endif // defined(VK_USE_PLATFORM_WAYLAND_KHR) + +#if defined(VK_USE_PLATFORM_WIN32_KHR) + +inline void variantWrap(const VkWin32SurfaceCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkWin32SurfaceCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImportMemoryWin32HandleInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImportMemoryWin32HandleInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExportMemoryWin32HandleInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExportMemoryWin32HandleInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkWin32KeyedMutexAcquireReleaseInfoNV& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkWin32KeyedMutexAcquireReleaseInfoNV)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImportMemoryWin32HandleInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImportMemoryWin32HandleInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExportMemoryWin32HandleInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExportMemoryWin32HandleInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryWin32HandlePropertiesKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryWin32HandlePropertiesKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkMemoryGetWin32HandleInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkMemoryGetWin32HandleInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkWin32KeyedMutexAcquireReleaseInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkWin32KeyedMutexAcquireReleaseInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImportSemaphoreWin32HandleInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImportSemaphoreWin32HandleInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExportSemaphoreWin32HandleInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExportSemaphoreWin32HandleInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkD3D12FenceSubmitInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkD3D12FenceSubmitInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSemaphoreGetWin32HandleInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSemaphoreGetWin32HandleInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkImportFenceWin32HandleInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkImportFenceWin32HandleInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkExportFenceWin32HandleInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkExportFenceWin32HandleInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkFenceGetWin32HandleInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkFenceGetWin32HandleInfoKHR)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSurfaceFullScreenExclusiveInfoEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSurfaceFullScreenExclusiveInfoEXT)); + copyIndirectData(*valueCopy); +} + +inline void variantWrap(const VkSurfaceCapabilitiesFullScreenExclusiveEXT& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_OUT_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.outStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkSurfaceCapabilitiesFullScreenExclusiveEXT)); + copyIndirectData(*valueCopy); +} + +#endif // defined(VK_USE_PLATFORM_WIN32_KHR) + +#if defined(VK_USE_PLATFORM_XCB_KHR) + +inline void variantWrap(const VkXcbSurfaceCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkXcbSurfaceCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +#endif // defined(VK_USE_PLATFORM_XCB_KHR) + +#if defined(VK_USE_PLATFORM_XLIB_KHR) + +inline void variantWrap(const VkXlibSurfaceCreateInfoKHR& value, VkVariantMWN& outVariant) +{ + outVariant.type = VK_VARIANT_TYPE_IN_STRUCTURE_MWN; + + auto valueCopy = allocType(); + outVariant.inStructureValue = reinterpret_cast(valueCopy); + + std::memcpy(valueCopy, &value, sizeof(VkXlibSurfaceCreateInfoKHR)); + copyIndirectData(*valueCopy); +} + +#endif // defined(VK_USE_PLATFORM_XLIB_KHR) + +inline void* copyNextPtr(const void* pNext) +{ + if (pNext == nullptr) { + return nullptr; + } + const VkStructureType sType = *static_cast(pNext); + void* pCopy = nullptr; + switch (sType) + { + case VK_STRUCTURE_TYPE_APPLICATION_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkApplicationInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceQueueCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkInstanceCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryAllocateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMappedMemoryRange)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkWriteDescriptorSet)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COPY_DESCRIPTOR_SET: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCopyDescriptorSet)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBufferCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBufferViewCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_BARRIER: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryBarrier)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBufferMemoryBarrier)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageMemoryBarrier)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageViewCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BIND_SPARSE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBindSparseInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkShaderModuleCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDescriptorSetLayoutCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDescriptorPoolCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDescriptorSetAllocateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineShaderStageCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COMPUTE_PIPELINE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkComputePipelineCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineVertexInputStateCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineInputAssemblyStateCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineTessellationStateCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineViewportStateCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineRasterizationStateCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineMultisampleStateCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineColorBlendStateCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineDynamicStateCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineDepthStencilStateCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkGraphicsPipelineCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineCacheCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineLayoutCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSamplerCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCommandPoolCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCommandBufferAllocateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCommandBufferInheritanceInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCommandBufferBeginInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRenderPassBeginInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRenderPassCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EVENT_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkEventCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_FENCE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkFenceCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSemaphoreCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkQueryPoolCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkFramebufferCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SUBMIT_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSubmitInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_MODE_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDisplayModeCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDisplaySurfaceCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_PRESENT_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDisplayPresentInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSwapchainCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PRESENT_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPresentInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEBUG_REPORT_CALLBACK_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDebugReportCallbackCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VALIDATION_FLAGS_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkValidationFlagsEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VALIDATION_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkValidationFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_RASTERIZATION_ORDER_AMD: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineRasterizationStateRasterizationOrderAMD)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_NAME_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDebugMarkerObjectNameInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEBUG_MARKER_OBJECT_TAG_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDebugMarkerObjectTagInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEBUG_MARKER_MARKER_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDebugMarkerMarkerInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_IMAGE_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDedicatedAllocationImageCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_BUFFER_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDedicatedAllocationBufferCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEDICATED_ALLOCATION_MEMORY_ALLOCATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDedicatedAllocationMemoryAllocateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExternalMemoryImageCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExportMemoryAllocateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDeviceGeneratedCommandsFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_PRIVATE_DATA_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDevicePrivateDataCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PRIVATE_DATA_SLOT_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPrivateDataSlotCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIVATE_DATA_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePrivateDataFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_GENERATED_COMMANDS_PROPERTIES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDeviceGeneratedCommandsPropertiesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMultiDrawPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_GRAPHICS_SHADER_GROUP_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkGraphicsShaderGroupCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_SHADER_GROUPS_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkGraphicsPipelineShaderGroupsCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_TOKEN_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkIndirectCommandsLayoutTokenNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_INDIRECT_COMMANDS_LAYOUT_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkIndirectCommandsLayoutCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkGeneratedCommandsInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_GENERATED_COMMANDS_MEMORY_REQUIREMENTS_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkGeneratedCommandsMemoryRequirementsInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFeatures2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceProperties2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkFormatProperties2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageFormatProperties2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImageFormatInfo2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkQueueFamilyProperties2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMemoryProperties2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSparseImageFormatProperties2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSparseImageFormatInfo2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PUSH_DESCRIPTOR_PROPERTIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePushDescriptorPropertiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRIVER_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDriverProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PRESENT_REGIONS_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPresentRegionsKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVariablePointersFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExternalImageFormatInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExternalImageFormatProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExternalBufferInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExternalBufferProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceIDProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExternalMemoryImageCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExternalMemoryBufferCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExportMemoryAllocateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_FD_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImportMemoryFdInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_FD_PROPERTIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryFdPropertiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_GET_FD_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryGetFdInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExternalSemaphoreInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExternalSemaphoreProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExportSemaphoreCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_FD_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImportSemaphoreFdInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_FD_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSemaphoreGetFdInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExternalFenceInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExternalFenceProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExportFenceCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMPORT_FENCE_FD_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImportFenceFdInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_FENCE_GET_FD_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkFenceGetFdInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMultiviewFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMultiviewProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRenderPassMultiviewCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSurfaceCapabilities2EXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_POWER_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDisplayPowerInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_EVENT_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceEventInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_EVENT_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDisplayEventInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_COUNTER_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSwapchainCounterCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceGroupProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryAllocateFlagsInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBindBufferMemoryInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_DEVICE_GROUP_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBindBufferMemoryDeviceGroupInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBindImageMemoryInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_DEVICE_GROUP_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBindImageMemoryDeviceGroupInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_RENDER_PASS_BEGIN_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceGroupRenderPassBeginInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_COMMAND_BUFFER_BEGIN_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceGroupCommandBufferBeginInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceGroupSubmitInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceGroupBindSparseInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_CAPABILITIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceGroupPresentCapabilitiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_SWAPCHAIN_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageSwapchainCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_SWAPCHAIN_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBindImageMemorySwapchainInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ACQUIRE_NEXT_IMAGE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAcquireNextImageInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_PRESENT_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceGroupPresentInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceGroupDeviceCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_GROUP_SWAPCHAIN_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceGroupSwapchainCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDescriptorUpdateTemplateCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_ID_FEATURES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePresentIdFeaturesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PRESENT_ID_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPresentIdKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENT_WAIT_FEATURES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePresentWaitFeaturesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_HDR_METADATA_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkHdrMetadataEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_NATIVE_HDR_SURFACE_CAPABILITIES_AMD: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDisplayNativeHdrSurfaceCapabilitiesAMD)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_DISPLAY_NATIVE_HDR_CREATE_INFO_AMD: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSwapchainDisplayNativeHdrCreateInfoAMD)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PRESENT_TIMES_INFO_GOOGLE: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPresentTimesInfoGOOGLE)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_W_SCALING_STATE_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineViewportWScalingStateCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SWIZZLE_STATE_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineViewportSwizzleStateCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DISCARD_RECTANGLE_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDiscardRectanglePropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_DISCARD_RECTANGLE_STATE_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineDiscardRectangleStateCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PER_VIEW_ATTRIBUTES_PROPERTIES_NVX: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMultiviewPerViewAttributesPropertiesNVX)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRenderPassInputAttachmentAspectCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SURFACE_INFO_2_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSurfaceInfo2KHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_2_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSurfaceCapabilities2KHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SURFACE_FORMAT_2_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSurfaceFormat2KHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_PROPERTIES_2_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDisplayProperties2KHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_PLANE_PROPERTIES_2_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDisplayPlaneProperties2KHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_MODE_PROPERTIES_2_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDisplayModeProperties2KHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_PLANE_INFO_2_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDisplayPlaneInfo2KHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DISPLAY_PLANE_CAPABILITIES_2_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDisplayPlaneCapabilities2KHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SHARED_PRESENT_SURFACE_CAPABILITIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSharedPresentSurfaceCapabilitiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevice16BitStorageFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSubgroupProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBufferMemoryRequirementsInfo2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_BUFFER_MEMORY_REQUIREMENTS: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceBufferMemoryRequirements)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageMemoryRequirementsInfo2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_SPARSE_MEMORY_REQUIREMENTS_INFO_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageSparseMemoryRequirementsInfo2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_IMAGE_MEMORY_REQUIREMENTS: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceImageMemoryRequirements)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryRequirements2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SPARSE_IMAGE_MEMORY_REQUIREMENTS_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSparseImageMemoryRequirements2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePointClippingProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryDedicatedRequirements)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryDedicatedAllocateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageViewUsageCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineTessellationDomainOriginStateCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSamplerYcbcrConversionInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSamplerYcbcrConversionCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBindImagePlaneMemoryInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImagePlaneMemoryRequirementsInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSamplerYcbcrConversionFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_IMAGE_FORMAT_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSamplerYcbcrConversionImageFormatProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_TEXTURE_LOD_GATHER_FORMAT_PROPERTIES_AMD: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkTextureLODGatherFormatPropertiesAMD)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_CONDITIONAL_RENDERING_BEGIN_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkConditionalRenderingBeginInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkProtectedSubmitInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceProtectedMemoryFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceProtectedMemoryProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceQueueInfo2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_TO_COLOR_STATE_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineCoverageToColorStateCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_FILTER_MINMAX_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSamplerFilterMinmaxProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SAMPLE_LOCATIONS_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSampleLocationsInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_SAMPLE_LOCATIONS_BEGIN_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRenderPassSampleLocationsBeginInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SAMPLE_LOCATIONS_STATE_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineSampleLocationsStateCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLE_LOCATIONS_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSampleLocationsPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MULTISAMPLE_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMultisamplePropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSamplerReductionModeCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTI_DRAW_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMultiDrawFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceBlendOperationAdvancedPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_ADVANCED_STATE_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineColorBlendAdvancedStateCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceInlineUniformBlockFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceInlineUniformBlockProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkWriteDescriptorSetInlineUniformBlock)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_INLINE_UNIFORM_BLOCK_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDescriptorPoolInlineUniformBlockCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_MODULATION_STATE_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineCoverageModulationStateCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageFormatListCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VALIDATION_CACHE_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkValidationCacheCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SHADER_MODULE_VALIDATION_CACHE_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkShaderModuleValidationCacheCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_3_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMaintenance3Properties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMaintenance4Features)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_4_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMaintenance4Properties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_SUPPORT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDescriptorSetLayoutSupport)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderDrawParametersFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderFloat16Int8Features)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FLOAT_CONTROLS_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFloatControlsProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceHostQueryResetFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_QUEUE_GLOBAL_PRIORITY_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceQueueGlobalPriorityCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GLOBAL_PRIORITY_QUERY_FEATURES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_GLOBAL_PRIORITY_PROPERTIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkQueueFamilyGlobalPriorityPropertiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_NAME_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDebugUtilsObjectNameInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_OBJECT_TAG_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDebugUtilsObjectTagInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_LABEL_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDebugUtilsLabelEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDebugUtilsMessengerCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEBUG_UTILS_MESSENGER_CALLBACK_DATA_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDebugUtilsMessengerCallbackDataEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDeviceMemoryReportFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_DEVICE_MEMORY_REPORT_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceDeviceMemoryReportCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_REPORT_CALLBACK_DATA_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceMemoryReportCallbackDataEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_HOST_POINTER_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImportMemoryHostPointerInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_HOST_POINTER_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryHostPointerPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_HOST_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExternalMemoryHostPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONSERVATIVE_RASTERIZATION_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceConservativeRasterizationPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_CALIBRATED_TIMESTAMP_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCalibratedTimestampInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_AMD: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderCorePropertiesAMD)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CORE_PROPERTIES_2_AMD: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderCoreProperties2AMD)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_CONSERVATIVE_STATE_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineRasterizationConservativeStateCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDescriptorIndexingFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDescriptorIndexingProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDescriptorSetLayoutBindingFlagsCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDescriptorSetVariableDescriptorCountAllocateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_LAYOUT_SUPPORT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDescriptorSetVariableDescriptorCountLayoutSupport)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAttachmentDescription2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAttachmentReference2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSubpassDescription2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSubpassDependency2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRenderPassCreateInfo2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SUBPASS_BEGIN_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSubpassBeginInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SUBPASS_END_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSubpassEndInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceTimelineSemaphoreFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceTimelineSemaphoreProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSemaphoreTypeCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkTimelineSemaphoreSubmitInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_WAIT_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSemaphoreWaitInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSemaphoreSignalInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_DIVISOR_STATE_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineVertexInputDivisorStateCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PCI_BUS_INFO_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePCIBusInfoPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_CONDITIONAL_RENDERING_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCommandBufferInheritanceConditionalRenderingInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevice8BitStorageFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceConditionalRenderingFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVulkanMemoryModelFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderAtomicInt64Features)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderAtomicFloatFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_FLOAT_2_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkQueueFamilyCheckpointPropertiesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCheckpointDataNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_STENCIL_RESOLVE_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDepthStencilResolveProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SUBPASS_DESCRIPTION_DEPTH_STENCIL_RESOLVE: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSubpassDescriptionDepthStencilResolve)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ASTC_DECODE_MODE_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageViewASTCDecodeModeEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ASTC_DECODE_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceASTCDecodeFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceTransformFeedbackFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceTransformFeedbackPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_STREAM_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineRasterizationStateStreamCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_REPRESENTATIVE_FRAGMENT_TEST_STATE_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineRepresentativeFragmentTestStateCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExclusiveScissorFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_EXCLUSIVE_SCISSOR_STATE_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineViewportExclusiveScissorStateCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceCornerSampledImageFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderImageFootprintFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_SHADING_RATE_IMAGE_STATE_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineViewportShadingRateImageStateCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShadingRateImageFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_PROPERTIES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShadingRateImagePropertiesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INVOCATION_MASK_FEATURES_HUAWEI: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceInvocationMaskFeaturesHUAWEI)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_COARSE_SAMPLE_ORDER_STATE_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineViewportCoarseSampleOrderStateCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMeshShaderFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_PROPERTIES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMeshShaderPropertiesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRayTracingShaderGroupCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RAY_TRACING_SHADER_GROUP_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRayTracingShaderGroupCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRayTracingPipelineCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRayTracingPipelineCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_GEOMETRY_TRIANGLES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkGeometryTrianglesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_GEOMETRY_AABB_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkGeometryAABBNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_GEOMETRY_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkGeometryNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BIND_ACCELERATION_STRUCTURE_MEMORY_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBindAccelerationStructureMemoryInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkWriteDescriptorSetAccelerationStructureKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkWriteDescriptorSetAccelerationStructureNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MEMORY_REQUIREMENTS_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureMemoryRequirementsInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceAccelerationStructureFeaturesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_FEATURES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRayTracingPipelineFeaturesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRayQueryFeaturesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_PROPERTIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceAccelerationStructurePropertiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PIPELINE_PROPERTIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRayTracingPipelinePropertiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRayTracingPropertiesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MAINTENANCE_1_FEATURES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDrmFormatModifierPropertiesListEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_DRM_FORMAT_MODIFIER_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImageDrmFormatModifierInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_LIST_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageDrmFormatModifierListCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_EXPLICIT_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageDrmFormatModifierExplicitCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_DRM_FORMAT_MODIFIER_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageDrmFormatModifierPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_STENCIL_USAGE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageStencilUsageCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OVERALLOCATION_CREATE_INFO_AMD: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceMemoryOverallocationCreateInfoAMD)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentDensityMapFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentDensityMap2FeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_FEATURES_QCOM: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentDensityMapPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_2_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentDensityMap2PropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_OFFSET_PROPERTIES_QCOM: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_FRAGMENT_DENSITY_MAP_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRenderPassFragmentDensityMapCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SUBPASS_FRAGMENT_DENSITY_MAP_OFFSET_END_INFO_QCOM: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSubpassFragmentDensityMapOffsetEndInfoQCOM)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceScalarBlockLayoutFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SURFACE_PROTECTED_CAPABILITIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSurfaceProtectedCapabilitiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceUniformBufferStandardLayoutFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDepthClipEnableFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineRasterizationDepthClipStateCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_BUDGET_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMemoryBudgetPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMemoryPriorityFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_PRIORITY_ALLOCATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryPriorityAllocateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PAGEABLE_DEVICE_LOCAL_MEMORY_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceBufferDeviceAddressFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBufferDeviceAddressInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BUFFER_OPAQUE_CAPTURE_ADDRESS_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBufferOpaqueCaptureAddressCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBufferDeviceAddressCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_IMAGE_FORMAT_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImageViewImageFormatInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_FILTER_CUBIC_IMAGE_VIEW_IMAGE_FORMAT_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkFilterCubicImageViewImageFormatPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImagelessFramebufferFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENTS_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkFramebufferAttachmentsCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_ATTACHMENT_IMAGE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkFramebufferAttachmentImageInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_ATTACHMENT_BEGIN_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRenderPassAttachmentBeginInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXTURE_COMPRESSION_ASTC_HDR_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceTextureCompressionASTCHDRFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceCooperativeMatrixFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_PROPERTIES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceCooperativeMatrixPropertiesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COOPERATIVE_MATRIX_PROPERTIES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCooperativeMatrixPropertiesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_HANDLE_INFO_NVX: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageViewHandleInfoNVX)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_ADDRESS_PROPERTIES_NVX: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageViewAddressPropertiesNVX)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_CREATION_FEEDBACK_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineCreationFeedbackCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePerformanceQueryFeaturesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_PROPERTIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePerformanceQueryPropertiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPerformanceCounterKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_COUNTER_DESCRIPTION_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPerformanceCounterDescriptionKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkQueryPoolPerformanceCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ACQUIRE_PROFILING_LOCK_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAcquireProfilingLockInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_QUERY_SUBMIT_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPerformanceQuerySubmitInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkHeadlessSurfaceCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceCoverageReductionModeFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COVERAGE_REDUCTION_STATE_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineCoverageReductionStateCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_FRAMEBUFFER_MIXED_SAMPLES_COMBINATION_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkFramebufferMixedSamplesCombinationNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_INITIALIZE_PERFORMANCE_API_INFO_INTEL: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkInitializePerformanceApiInfoINTEL)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_QUERY_POOL_PERFORMANCE_QUERY_CREATE_INFO_INTEL: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkQueryPoolPerformanceQueryCreateInfoINTEL)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_MARKER_INFO_INTEL: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPerformanceMarkerInfoINTEL)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_STREAM_MARKER_INFO_INTEL: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPerformanceStreamMarkerInfoINTEL)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_OVERRIDE_INFO_INTEL: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPerformanceOverrideInfoINTEL)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PERFORMANCE_CONFIGURATION_ACQUIRE_INFO_INTEL: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPerformanceConfigurationAcquireInfoINTEL)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderClockFeaturesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceIndexTypeUint8FeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_PROPERTIES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderSMBuiltinsPropertiesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SM_BUILTINS_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_REFERENCE_STENCIL_LAYOUT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAttachmentReferenceStencilLayout)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVE_TOPOLOGY_LIST_RESTART_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_DESCRIPTION_STENCIL_LAYOUT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAttachmentDescriptionStencilLayout)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_PROPERTIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineExecutablePropertiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineExecutableInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_STATISTIC_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineExecutableStatisticKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_EXECUTABLE_INTERNAL_REPRESENTATION_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineExecutableInternalRepresentationKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderDemoteToHelperInvocationFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceTexelBufferAlignmentProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSubgroupSizeControlFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSubgroupSizeControlProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_REQUIRED_SUBGROUP_SIZE_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineShaderStageRequiredSubgroupSizeCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SUBPASS_SHADING_PIPELINE_CREATE_INFO_HUAWEI: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSubpassShadingPipelineCreateInfoHUAWEI)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_PROPERTIES_HUAWEI: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSubpassShadingPropertiesHUAWEI)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_OPAQUE_CAPTURE_ADDRESS_ALLOCATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryOpaqueCaptureAddressAllocateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_MEMORY_OPAQUE_CAPTURE_ADDRESS_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceMemoryOpaqueCaptureAddressInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceLineRasterizationFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceLineRasterizationPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_LINE_STATE_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineRasterizationLineStateCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_CREATION_CACHE_CONTROL_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePipelineCreationCacheControlFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVulkan11Features)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVulkan11Properties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVulkan12Features)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVulkan12Properties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVulkan13Features)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_3_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVulkan13Properties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COMPILER_CONTROL_CREATE_INFO_AMD: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineCompilerControlCreateInfoAMD)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceCoherentMemoryFeaturesAMD)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TOOL_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceToolProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSamplerCustomBorderColorCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceCustomBorderColorPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceCustomBorderColorFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSamplerBorderColorComponentMappingCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BORDER_COLOR_SWIZZLE_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceBorderColorSwizzleFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_TRIANGLES_DATA_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureGeometryTrianglesDataKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_AABBS_DATA_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureGeometryAabbsDataKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_INSTANCES_DATA_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureGeometryInstancesDataKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureGeometryKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_GEOMETRY_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureBuildGeometryInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_DEVICE_ADDRESS_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureDeviceAddressInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_VERSION_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureVersionInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCopyAccelerationStructureInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COPY_ACCELERATION_STRUCTURE_TO_MEMORY_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCopyAccelerationStructureToMemoryInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COPY_MEMORY_TO_ACCELERATION_STRUCTURE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCopyMemoryToAccelerationStructureInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RAY_TRACING_PIPELINE_INTERFACE_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRayTracingPipelineInterfaceCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_LIBRARY_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineLibraryCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExtendedDynamicStateFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_2_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExtendedDynamicState2FeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_TRANSFORM_BEGIN_INFO_QCOM: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRenderPassTransformBeginInfoQCOM)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COPY_COMMAND_TRANSFORM_INFO_QCOM: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCopyCommandTransformInfoQCOM)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDER_PASS_TRANSFORM_INFO_QCOM: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCommandBufferInheritanceRenderPassTransformInfoQCOM)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DIAGNOSTICS_CONFIG_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDiagnosticsConfigFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEVICE_DIAGNOSTICS_CONFIG_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDeviceDiagnosticsConfigCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ZERO_INITIALIZE_WORKGROUP_MEMORY_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_UNIFORM_CONTROL_FLOW_FEATURES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRobustness2FeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ROBUSTNESS_2_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRobustness2PropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImageRobustnessFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_WORKGROUP_MEMORY_EXPLICIT_LAYOUT_FEATURES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_4444_FORMATS_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevice4444FormatsFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_SHADING_FEATURES_HUAWEI: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSubpassShadingFeaturesHUAWEI)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BUFFER_COPY_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBufferCopy2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_COPY_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageCopy2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_BLIT_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageBlit2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BUFFER_IMAGE_COPY_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBufferImageCopy2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_RESOLVE_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageResolve2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COPY_BUFFER_INFO_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCopyBufferInfo2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COPY_IMAGE_INFO_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCopyImageInfo2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BLIT_IMAGE_INFO_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBlitImageInfo2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COPY_BUFFER_TO_IMAGE_INFO_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCopyBufferToImageInfo2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COPY_IMAGE_TO_BUFFER_INFO_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCopyImageToBufferInfo2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RESOLVE_IMAGE_INFO_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkResolveImageInfo2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_ATOMIC_INT64_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkFragmentShadingRateAttachmentInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_STATE_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineFragmentShadingRateStateCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_FEATURES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentShadingRateFeaturesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentShadingRatePropertiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentShadingRateKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_TERMINATE_INVOCATION_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderTerminateInvocationFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentShadingRateEnumsFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_ENUMS_PROPERTIES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentShadingRateEnumsPropertiesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_FRAGMENT_SHADING_RATE_ENUM_STATE_CREATE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineFragmentShadingRateEnumStateCreateInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_BUILD_SIZES_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureBuildSizesInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_2D_VIEW_OF_3D_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImage2DViewOf3DFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MUTABLE_DESCRIPTOR_TYPE_FEATURES_VALVE: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MUTABLE_DESCRIPTOR_TYPE_CREATE_INFO_VALVE: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMutableDescriptorTypeCreateInfoVALVE)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_CONTROL_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDepthClipControlFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_DEPTH_CLIP_CONTROL_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineViewportDepthClipControlCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_INPUT_DYNAMIC_STATE_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_MEMORY_RDMA_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceExternalMemoryRDMAFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VERTEX_INPUT_BINDING_DESCRIPTION_2_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVertexInputBindingDescription2EXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VERTEX_INPUT_ATTRIBUTE_DESCRIPTION_2_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVertexInputAttributeDescription2EXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COLOR_WRITE_ENABLE_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceColorWriteEnableFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_COLOR_WRITE_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineColorWriteCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_BARRIER_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryBarrier2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageMemoryBarrier2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBufferMemoryBarrier2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DEPENDENCY_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDependencyInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSemaphoreSubmitInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_SUBMIT_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCommandBufferSubmitInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SUBMIT_INFO_2: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSubmitInfo2)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_CHECKPOINT_PROPERTIES_2_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkQueueFamilyCheckpointProperties2NV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_CHECKPOINT_DATA_2_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCheckpointData2NV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SYNCHRONIZATION_2_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSynchronization2Features)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRIMITIVES_GENERATED_QUERY_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePrimitivesGeneratedQueryFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SUBPASS_RESOLVE_PERFORMANCE_QUERY_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSubpassResolvePerformanceQueryEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MULTISAMPLED_RENDER_TO_SINGLE_SAMPLED_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMultisampledRenderToSingleSampledInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INHERITED_VIEWPORT_SCISSOR_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceInheritedViewportScissorFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_VIEWPORT_SCISSOR_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCommandBufferInheritanceViewportScissorInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_2_PLANE_444_FORMATS_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceProvokingVertexFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceProvokingVertexPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_PROVOKING_VERTEX_STATE_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineRasterizationProvokingVertexStateCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_CU_MODULE_CREATE_INFO_NVX: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCuModuleCreateInfoNVX)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_CU_FUNCTION_CREATE_INFO_NVX: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCuFunctionCreateInfoNVX)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_CU_LAUNCH_INFO_NVX: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCuLaunchInfoNVX)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderIntegerDotProductFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderIntegerDotProductProperties)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DRM_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDrmPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentShaderBarycentricFeaturesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_PROPERTIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceFragmentShaderBarycentricPropertiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_MOTION_BLUR_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRayTracingMotionBlurFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_GEOMETRY_MOTION_TRIANGLES_DATA_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureGeometryMotionTrianglesDataNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ACCELERATION_STRUCTURE_MOTION_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAccelerationStructureMotionInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_GET_REMOTE_ADDRESS_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryGetRemoteAddressInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RGBA10X6_FORMATS_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceRGBA10X6FormatsFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_3: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkFormatProperties3)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DRM_FORMAT_MODIFIER_PROPERTIES_LIST_2_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDrmFormatModifierPropertiesList2EXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineRenderingCreateInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RENDERING_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRenderingInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRenderingAttachmentInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_SHADING_RATE_ATTACHMENT_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRenderingFragmentShadingRateAttachmentInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RENDERING_FRAGMENT_DENSITY_MAP_ATTACHMENT_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRenderingFragmentDensityMapAttachmentInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDynamicRenderingFeatures)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_COMMAND_BUFFER_INHERITANCE_RENDERING_INFO: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkCommandBufferInheritanceRenderingInfo)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ATTACHMENT_SAMPLE_COUNT_INFO_AMD: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAttachmentSampleCountInfoAMD)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MULTIVIEW_PER_VIEW_ATTRIBUTES_INFO_NVX: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMultiviewPerViewAttributesInfoNVX)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_VIEW_MIN_LOD_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImageViewMinLodFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_VIEW_MIN_LOD_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageViewMinLodCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINEAR_COLOR_ATTACHMENT_FEATURES_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceLinearColorAttachmentFeaturesNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceGraphicsPipelineLibraryFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GRAPHICS_PIPELINE_LIBRARY_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceGraphicsPipelineLibraryPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_LIBRARY_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkGraphicsPipelineLibraryCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_SET_HOST_MAPPING_FEATURES_VALVE: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceDescriptorSetHostMappingFeaturesVALVE)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_BINDING_REFERENCE_VALVE: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDescriptorSetBindingReferenceVALVE)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_HOST_MAPPING_INFO_VALVE: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDescriptorSetLayoutHostMappingInfoVALVE)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_MODULE_IDENTIFIER_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderModuleIdentifierPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_MODULE_IDENTIFIER_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineShaderStageModuleIdentifierCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SHADER_MODULE_IDENTIFIER_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkShaderModuleIdentifierEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_CONTROL_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageCompressionControlEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImageCompressionControlFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_COMPRESSION_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageCompressionPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_COMPRESSION_CONTROL_SWAPCHAIN_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_SUBRESOURCE_2_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageSubresource2EXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SUBRESOURCE_LAYOUT_2_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSubresourceLayout2EXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_CONTROL_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRenderPassCreationControlEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_CREATION_FEEDBACK_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRenderPassCreationFeedbackCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_RENDER_PASS_SUBPASS_FEEDBACK_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkRenderPassSubpassFeedbackCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBPASS_MERGE_FEEDBACK_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_PROPERTIES_IDENTIFIER_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelinePropertiesIdentifierEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_PROPERTIES_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePipelinePropertiesFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_EARLY_AND_LATE_FRAGMENT_TESTS_FEATURES_AMD: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_NON_SEAMLESS_CUBE_MAP_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_FEATURES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePipelineRobustnessFeaturesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PIPELINE_ROBUSTNESS_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPipelineRobustnessCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_ROBUSTNESS_PROPERTIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePipelineRobustnessPropertiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; +#if defined(VK_USE_PLATFORM_ANDROID_KHR) + + case VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAndroidSurfaceCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_NATIVE_BUFFER_ANDROID: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkNativeBufferANDROID)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SWAPCHAIN_IMAGE_CREATE_INFO_ANDROID: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSwapchainImageCreateInfoANDROID)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PRESENTATION_PROPERTIES_ANDROID: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePresentationPropertiesANDROID)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMPORT_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImportAndroidHardwareBufferInfoANDROID)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_USAGE_ANDROID: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAndroidHardwareBufferUsageANDROID)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_PROPERTIES_ANDROID: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAndroidHardwareBufferPropertiesANDROID)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_GET_ANDROID_HARDWARE_BUFFER_INFO_ANDROID: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryGetAndroidHardwareBufferInfoANDROID)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_ANDROID_HARDWARE_BUFFER_FORMAT_PROPERTIES_ANDROID: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkAndroidHardwareBufferFormatPropertiesANDROID)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXTERNAL_FORMAT_ANDROID: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExternalFormatANDROID)); + copyIndirectData(*static_cast(pCopy)); + break; +#endif // defined(VK_USE_PLATFORM_ANDROID_KHR) + +#if defined(VK_USE_PLATFORM_DIRECTFB_EXT) + + case VK_STRUCTURE_TYPE_DIRECTFB_SURFACE_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkDirectFBSurfaceCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; +#endif // defined(VK_USE_PLATFORM_DIRECTFB_EXT) + +#if defined(VK_USE_PLATFORM_FUCHSIA) + + case VK_STRUCTURE_TYPE_IMAGEPIPE_SURFACE_CREATE_INFO_FUCHSIA: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImagePipeSurfaceCreateInfoFUCHSIA)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_ZIRCON_HANDLE_INFO_FUCHSIA: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImportMemoryZirconHandleInfoFUCHSIA)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_ZIRCON_HANDLE_PROPERTIES_FUCHSIA: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryZirconHandlePropertiesFUCHSIA)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_GET_ZIRCON_HANDLE_INFO_FUCHSIA: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryGetZirconHandleInfoFUCHSIA)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_ZIRCON_HANDLE_INFO_FUCHSIA: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImportSemaphoreZirconHandleInfoFUCHSIA)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_ZIRCON_HANDLE_INFO_FUCHSIA: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSemaphoreGetZirconHandleInfoFUCHSIA)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_BUFFER_COLLECTION_FUCHSIA: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImportMemoryBufferCollectionFUCHSIA)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_IMAGE_CREATE_INFO_FUCHSIA: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBufferCollectionImageCreateInfoFUCHSIA)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_BUFFER_CREATE_INFO_FUCHSIA: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBufferCollectionBufferCreateInfoFUCHSIA)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CREATE_INFO_FUCHSIA: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBufferCollectionCreateInfoFUCHSIA)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_PROPERTIES_FUCHSIA: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBufferCollectionPropertiesFUCHSIA)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BUFFER_CONSTRAINTS_INFO_FUCHSIA: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBufferConstraintsInfoFUCHSIA)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SYSMEM_COLOR_SPACE_FUCHSIA: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSysmemColorSpaceFUCHSIA)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_FORMAT_CONSTRAINTS_INFO_FUCHSIA: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageFormatConstraintsInfoFUCHSIA)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMAGE_CONSTRAINTS_INFO_FUCHSIA: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImageConstraintsInfoFUCHSIA)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BUFFER_COLLECTION_CONSTRAINTS_INFO_FUCHSIA: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBufferCollectionConstraintsInfoFUCHSIA)); + copyIndirectData(*static_cast(pCopy)); + break; +#endif // defined(VK_USE_PLATFORM_FUCHSIA) + +#if defined(VK_USE_PLATFORM_GGP) + + case VK_STRUCTURE_TYPE_STREAM_DESCRIPTOR_SURFACE_CREATE_INFO_GGP: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkStreamDescriptorSurfaceCreateInfoGGP)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PRESENT_FRAME_TOKEN_GGP: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPresentFrameTokenGGP)); + copyIndirectData(*static_cast(pCopy)); + break; +#endif // defined(VK_USE_PLATFORM_GGP) + +#if defined(VK_USE_PLATFORM_IOS_MVK) + + case VK_STRUCTURE_TYPE_IOS_SURFACE_CREATE_INFO_MVK: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkIOSSurfaceCreateInfoMVK)); + copyIndirectData(*static_cast(pCopy)); + break; +#endif // defined(VK_USE_PLATFORM_IOS_MVK) + +#if defined(VK_USE_PLATFORM_MACOS_MVK) + + case VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMacOSSurfaceCreateInfoMVK)); + copyIndirectData(*static_cast(pCopy)); + break; +#endif // defined(VK_USE_PLATFORM_MACOS_MVK) + +#if defined(VK_USE_PLATFORM_METAL_EXT) + + case VK_STRUCTURE_TYPE_METAL_SURFACE_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMetalSurfaceCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECT_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExportMetalObjectCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_OBJECTS_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExportMetalObjectsInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_DEVICE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExportMetalDeviceInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_COMMAND_QUEUE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExportMetalCommandQueueInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_BUFFER_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExportMetalBufferInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMPORT_METAL_BUFFER_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImportMetalBufferInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_TEXTURE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExportMetalTextureInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMPORT_METAL_TEXTURE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImportMetalTextureInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_IO_SURFACE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExportMetalIOSurfaceInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMPORT_METAL_IO_SURFACE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImportMetalIOSurfaceInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXPORT_METAL_SHARED_EVENT_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExportMetalSharedEventInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMPORT_METAL_SHARED_EVENT_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImportMetalSharedEventInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; +#endif // defined(VK_USE_PLATFORM_METAL_EXT) + +#if defined(VK_ENABLE_BETA_EXTENSIONS) + + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_FEATURES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePortabilitySubsetFeaturesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PORTABILITY_SUBSET_PROPERTIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDevicePortabilitySubsetPropertiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_VIDEO_PROPERTIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkQueueFamilyVideoPropertiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_QUEUE_FAMILY_QUERY_RESULT_STATUS_PROPERTIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkQueueFamilyQueryResultStatusPropertiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_LIST_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoProfileListInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VIDEO_FORMAT_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkPhysicalDeviceVideoFormatInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_FORMAT_PROPERTIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoFormatPropertiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_PROFILE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoProfileInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_CAPABILITIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoCapabilitiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_SESSION_MEMORY_REQUIREMENTS_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoSessionMemoryRequirementsKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_BIND_VIDEO_SESSION_MEMORY_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkBindVideoSessionMemoryInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_PICTURE_RESOURCE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoPictureResourceInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_REFERENCE_SLOT_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoReferenceSlotInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_CAPABILITIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeCapabilitiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_USAGE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeUsageInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PROFILE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH264ProfileInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_CAPABILITIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH264CapabilitiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH264SessionParametersAddInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH264SessionParametersCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_PICTURE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH264PictureInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_DPB_SLOT_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH264DpbSlotInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H264_MVC_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH264MvcInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PROFILE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH265ProfileInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_CAPABILITIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH265CapabilitiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH265SessionParametersAddInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH265SessionParametersCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_PICTURE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH265PictureInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_DECODE_H265_DPB_SLOT_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoDecodeH265DpbSlotInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_SESSION_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoSessionCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoSessionParametersCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_SESSION_PARAMETERS_UPDATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoSessionParametersUpdateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_BEGIN_CODING_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoBeginCodingInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_END_CODING_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEndCodingInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_CODING_CONTROL_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoCodingControlInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_USAGE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeUsageInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeRateControlInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_RATE_CONTROL_LAYER_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeRateControlLayerInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_CAPABILITIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeCapabilitiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_CAPABILITIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264CapabilitiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_ADD_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264SessionParametersAddInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_SESSION_PARAMETERS_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264SessionParametersCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_DPB_SLOT_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264DpbSlotInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_VCL_FRAME_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264VclFrameInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_REFERENCE_LISTS_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264ReferenceListsInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_EMIT_PICTURE_PARAMETERS_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264EmitPictureParametersInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_PROFILE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264ProfileInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_NALU_SLICE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264NaluSliceInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264RateControlInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H264_RATE_CONTROL_LAYER_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH264RateControlLayerInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_CAPABILITIES_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265CapabilitiesEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_ADD_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265SessionParametersAddInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_SESSION_PARAMETERS_CREATE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265SessionParametersCreateInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_VCL_FRAME_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265VclFrameInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_EMIT_PICTURE_PARAMETERS_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265EmitPictureParametersInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_NALU_SLICE_SEGMENT_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265NaluSliceSegmentInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265RateControlInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_RATE_CONTROL_LAYER_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265RateControlLayerInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_PROFILE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265ProfileInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_DPB_SLOT_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265DpbSlotInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_VIDEO_ENCODE_H265_REFERENCE_LISTS_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkVideoEncodeH265ReferenceListsInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; +#endif // defined(VK_ENABLE_BETA_EXTENSIONS) + +#if defined(VK_USE_PLATFORM_SCREEN_QNX) + + case VK_STRUCTURE_TYPE_SCREEN_SURFACE_CREATE_INFO_QNX: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkScreenSurfaceCreateInfoQNX)); + copyIndirectData(*static_cast(pCopy)); + break; +#endif // defined(VK_USE_PLATFORM_SCREEN_QNX) + +#if defined(VK_USE_PLATFORM_VI_NN) + + case VK_STRUCTURE_TYPE_VI_SURFACE_CREATE_INFO_NN: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkViSurfaceCreateInfoNN)); + copyIndirectData(*static_cast(pCopy)); + break; +#endif // defined(VK_USE_PLATFORM_VI_NN) + +#if defined(VK_USE_PLATFORM_WAYLAND_KHR) + + case VK_STRUCTURE_TYPE_WAYLAND_SURFACE_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkWaylandSurfaceCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; +#endif // defined(VK_USE_PLATFORM_WAYLAND_KHR) + +#if defined(VK_USE_PLATFORM_WIN32_KHR) + + case VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkWin32SurfaceCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImportMemoryWin32HandleInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExportMemoryWin32HandleInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_NV: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkWin32KeyedMutexAcquireReleaseInfoNV)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImportMemoryWin32HandleInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXPORT_MEMORY_WIN32_HANDLE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExportMemoryWin32HandleInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_WIN32_HANDLE_PROPERTIES_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryWin32HandlePropertiesKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_MEMORY_GET_WIN32_HANDLE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkMemoryGetWin32HandleInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_WIN32_KEYED_MUTEX_ACQUIRE_RELEASE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkWin32KeyedMutexAcquireReleaseInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImportSemaphoreWin32HandleInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_WIN32_HANDLE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExportSemaphoreWin32HandleInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_D3D12_FENCE_SUBMIT_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkD3D12FenceSubmitInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SEMAPHORE_GET_WIN32_HANDLE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSemaphoreGetWin32HandleInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_IMPORT_FENCE_WIN32_HANDLE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkImportFenceWin32HandleInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_EXPORT_FENCE_WIN32_HANDLE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkExportFenceWin32HandleInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_FENCE_GET_WIN32_HANDLE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkFenceGetWin32HandleInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SURFACE_FULL_SCREEN_EXCLUSIVE_INFO_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSurfaceFullScreenExclusiveInfoEXT)); + copyIndirectData(*static_cast(pCopy)); + break; + case VK_STRUCTURE_TYPE_SURFACE_CAPABILITIES_FULL_SCREEN_EXCLUSIVE_EXT: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkSurfaceCapabilitiesFullScreenExclusiveEXT)); + copyIndirectData(*static_cast(pCopy)); + break; +#endif // defined(VK_USE_PLATFORM_WIN32_KHR) + +#if defined(VK_USE_PLATFORM_XCB_KHR) + + case VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkXcbSurfaceCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; +#endif // defined(VK_USE_PLATFORM_XCB_KHR) + +#if defined(VK_USE_PLATFORM_XLIB_KHR) + + case VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR: + pCopy = allocType(); + std::memcpy(pCopy, pNext, sizeof(VkXlibSurfaceCreateInfoKHR)); + copyIndirectData(*static_cast(pCopy)); + break; +#endif // defined(VK_USE_PLATFORM_XLIB_KHR) + + default: break; + } + return pCopy; +} +} // namespace vk_capture + +#endif // VK_CAPTURE_VARIANT_WRAP_HPP_INCLUDED diff --git a/thirdparty/vulkan-docs b/thirdparty/vulkan-docs new file mode 160000 index 0000000..09d1205 --- /dev/null +++ b/thirdparty/vulkan-docs @@ -0,0 +1 @@ +Subproject commit 09d120580acb942d9cc3a96c863815a05990893c